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.

CMakeLists.txt

@@ -10,23 +10,16 @@ if(IPHONE)
 endif(IPHONE)
 
 if(CMAKE_COMPILER_IS_GNUCC)
-  set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -pedantic -Wno-long-long ${CMAKE_CXX_FLAGS}")
+  set(CMAKE_CXX_FLAGS "-O2 -Wall -pedantic -Wextra")
 endif(CMAKE_COMPILER_IS_GNUCC)
 
-if(MSVC)
-  set(LIB_TYPE) # I can't figure out how CMake handles Windows shared libraries
-  set(CMAKE_CXX_FLAGS "/W3 /wd4127 /wd4355 /D_SCL_SECURE_NO_WARNINGS ${CMAKE_CXX_FLAGS}")
-endif(MSVC)
-
 set(YAML_CPP_VERSION_MAJOR "0")
 set(YAML_CPP_VERSION_MINOR "2")
-set(YAML_CPP_VERSION_PATCH "5")
+set(YAML_CPP_VERSION_PATCH "0")
 set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")
 
 enable_testing()
 
-option(YAML_CPP_BUILD_TOOLS "Enables or disables testing and parse tools" true)
-
 if(WIN32)
   set(_library_dir bin) # .dll are in PATH, like executables
 else(WIN32)
@@ -43,9 +36,9 @@ set(_INSTALL_DESTINATIONS
 	ARCHIVE DESTINATION lib${LIB_SUFFIX}
 )
 #
-file(GLOB public_headers include/[a-z]*.h)
-file(GLOB private_headers src/[a-z]*.h)
-file(GLOB sources src/[a-z]*.cpp)
+file(GLOB public_headers include/*.h)
+file(GLOB private_headers src/*.h)
+file(GLOB sources src/*.cpp)
 
 include_directories(${YAML_CPP_SOURCE_DIR}/include)
 add_library(yaml-cpp
@@ -71,7 +64,5 @@ if(UNIX)
 	install(FILES ${PC_FILE} DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
 endif(UNIX)
 
-if(YAML_CPP_BUILD_TOOLS)
-	add_subdirectory (test)
-	add_subdirectory (util)
-endif(YAML_CPP_BUILD_TOOLS)
+add_subdirectory (yaml-reader)
+add_subdirectory (util)

include/aliasmanager.h

@@ -1,38 +0,0 @@
-#pragma once
-
-#ifndef ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include "anchor.h"
-#include <map>
-
-namespace YAML
-{
-	class Node;
-	
-	class AliasManager
-	{
-	public:
-		AliasManager();
-		
-		void RegisterReference(const Node& node);
-		
-		const Node *LookupReference(const Node& node) const;
-		anchor_t LookupAnchor(const Node& node) const;
-		
-	private:
-		const Node *_LookupReference(const Node& oldIdentity) const;
-		anchor_t _CreateNewAnchor();
-		
-	private:
-		typedef std::map<const Node*, const Node*> NodeByNode;
-		NodeByNode m_newIdentityByOldIdentity;
-		
-		typedef std::map<const Node*, anchor_t> AnchorByIdentity;
-		AnchorByIdentity m_anchorByIdentity;
-		
-		anchor_t m_curAnchor;
-	};
-}
-
-#endif // ALIASMANAGER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/anchor.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include <cstddef>
-
-namespace YAML
-{
-	typedef std::size_t anchor_t;
-	const anchor_t NullAnchor = 0;
-}
-
-#endif // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/anchordict.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#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/conversion.h

@@ -5,27 +5,41 @@
 
 
 #include "null.h"
-#include "traits.h"
 #include <string>
 #include <sstream>
 
 namespace YAML
 {
-	inline bool Convert(const std::string& input, std::string& output) {
+	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);
 	
-	bool Convert(const std::string& input, bool& output);
-	bool Convert(const std::string& input, _Null& output);
-	
-	template <typename T> 
-	inline bool Convert(const std::string& input, T& output, typename enable_if<is_numeric<T> >::type * = 0) {
-		std::stringstream stream(input);
-		stream.unsetf(std::ios::dec);
-		stream >> output;
-		return !!stream;
-	}
+	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/emitfromevents.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include "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 std::string& tag, 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/emitter.h

@@ -9,7 +9,6 @@
 #include "null.h"
 #include <memory>
 #include <string>
-#include <sstream>
 
 namespace YAML
 {
@@ -30,7 +29,6 @@ namespace YAML
 		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);
@@ -46,23 +44,16 @@ namespace YAML
 		
 		// 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 _Tag& tag);
 		Emitter& Write(const _Comment& comment);
 		Emitter& Write(const _Null& null);
 		
-		template <typename T>
-		Emitter& WriteIntegralType(T value);
-		
-		template <typename T>
-		Emitter& WriteStreamable(T value);
-
-	private:
-		void PreWriteIntegralType(std::stringstream& str);
-		void PostWriteIntegralType(const std::stringstream& str);
-	
 	private:
 		enum ATOMIC_TYPE { AT_SCALAR, AT_SEQ, AT_BLOCK_SEQ, AT_FLOW_SEQ, AT_MAP, AT_BLOCK_MAP, AT_FLOW_MAP };
 		
@@ -77,69 +68,24 @@ namespace YAML
 		void EmitEndMap();
 		void EmitKey();
 		void EmitValue();
-		void EmitKindTag();
-		void EmitTag(bool verbatim, const _Tag& tag);
 		
 	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;
-		
-		PreAtomicWrite();
-		EmitSeparationIfNecessary();
-		
-		std::stringstream str;
-		str << value;
-		m_stream << str.str();
-		
-		PostAtomicWrite();
-		return *this;
-	}
-	
 	// overloads of insertion
-	inline Emitter& operator << (Emitter& emitter, const std::string& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, bool v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Alias& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Anchor& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Tag& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Comment& v) { return emitter.Write(v); }
-	inline Emitter& operator << (Emitter& emitter, const _Null& v) { return emitter.Write(v); }
-
-	inline Emitter& operator << (Emitter& emitter, const 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, float v) { return emitter.WriteStreamable(v); }
-	inline Emitter& operator << (Emitter& emitter, double v) { return emitter.WriteStreamable(v); }
+	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);
 	}

include/emittermanip.h

@@ -11,11 +11,6 @@ namespace YAML
 	enum EMITTER_MANIP {
 		// general manipulators
 		Auto,
-		TagByKind,
-
-		// output character set
-		EmitNonAscii,
-		EscapeNonAscii,
 		
 		// string manipulators
 		// Auto, // duplicate
@@ -81,26 +76,6 @@ namespace YAML
 	inline _Anchor Anchor(const std::string content) {
 		return _Anchor(content);
 	}
-	
-	struct _Tag {
-		explicit _Tag(const std::string& content_)
-		: content(content_), verbatim(true)
-		{
-		}
-		std::string content;
-		bool verbatim;
-	};
-	
-	typedef _Tag VerbatimTag;
-	
-	struct LocalTag : public _Tag
-	{
-		explicit LocalTag(const std::string& content_)
-		: _Tag(content_)
-		{
-			verbatim = false;
-		}
-	};
 
 	struct _Comment {
 		_Comment(const std::string& content_): content(content_) {}

include/eventhandler.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include "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 std::string& tag, 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/exceptions.h

@@ -5,7 +5,6 @@
 
 
 #include "mark.h"
-#include "traits.h"
 #include <exception>
 #include <string>
 #include <sstream>
@@ -18,12 +17,7 @@ namespace YAML
 		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 REPEATED_YAML_DIRECTIVE= "repeated YAML directive";
 		const std::string TAG_DIRECTIVE_ARGS     = "TAG directives must have exactly two arguments";
-		const std::string REPEATED_TAG_DIRECTIVE = "repeated TAG directive";
-		const std::string CHAR_IN_TAG_HANDLE     = "illegal character found while scanning tag handle";
-		const std::string TAG_WITH_NO_SUFFIX     = "tag handle with no suffix";
-		const std::string END_OF_VERBATIM_TAG    = "end of verbatim tag not found";
 		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";
@@ -63,27 +57,10 @@ namespace YAML
 		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 INVALID_TAG            = "invalid tag";
 		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";
-
-		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) {
-			return KEY_NOT_FOUND + ": " + key;
-		}
-		
-		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::exception {
@@ -125,23 +102,22 @@ namespace YAML
 
 	class KeyNotFound: public RepresentationException {
 	public:
-		template <typename T>
-		KeyNotFound(const Mark& mark_, const T& key_)
-			: RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {}
+		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(key_) {}
-		virtual ~TypedKeyNotFound() throw() {}
+			: KeyNotFound(mark_), key(key_) {}
+		~TypedKeyNotFound() throw() {}
 
 		T key;
 	};
 
 	template <typename T>
-	inline TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) {
+	TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) {
 		return TypedKeyNotFound <T> (mark, key);
 	}
 

include/graphbuilder.h

@@ -1,117 +0,0 @@
-#ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include <string>
-
-namespace YAML
-{
-  struct Mark;
-  
-  // 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 std::string& tag, 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 std::string& tag, void* pParentNode) {
-      return CheckType<Node>(m_impl.NewNull(tag, 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);}
-  };
-}
-
-#endif // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/node.h

@@ -9,6 +9,7 @@
 #include "iterator.h"
 #include "mark.h"
 #include "noncopyable.h"
+#include "parserstate.h"
 #include <iostream>
 #include <string>
 #include <vector>
@@ -17,12 +18,9 @@
 
 namespace YAML
 {
-	class AliasManager;
 	class Content;
 	class Scanner;
 	class Emitter;
-	class EventHandler;
-	struct NodeProperties;
 
 	enum CONTENT_TYPE { CT_NONE, CT_SCALAR, CT_SEQUENCE, CT_MAP };
 
@@ -34,16 +32,7 @@ namespace YAML
 
 		void Clear();
 		std::auto_ptr<Node> Clone() const;
-		void EmitEvents(EventHandler& eventHandler) const;
-		void EmitEvents(AliasManager& am, EventHandler& eventHandler) const;
-
-		void Init(CONTENT_TYPE type, const Mark& mark, const std::string& tag);
-		void InitNull(const std::string& tag);
-		void InitAlias(const Mark& mark, const Node& identity);
-		
-		void SetData(const std::string& data);
-		void Append(std::auto_ptr<Node> pNode);
-		void Insert(std::auto_ptr<Node> pKey, std::auto_ptr<Node> pValue);
+		void Parse(Scanner *pScanner, const ParserState& state);
 
 		CONTENT_TYPE GetType() const;
 
@@ -64,9 +53,6 @@ namespace YAML
 
 		template <typename T>
 		const T Read() const;
-		
-		template <typename T>
-		operator T() const;
 
 		template <typename T>
 		friend void operator >> (const Node& node, T& value);
@@ -86,9 +72,6 @@ namespace YAML
 		const Node *Identity() const { return m_pIdentity; }
 		bool IsAlias() const { return m_alias; }
 		bool IsReferenced() const { return m_referenced; }
-		
-		// for tags
-		const std::string GetTag() const { return IsAlias() ? m_pIdentity->GetTag() : m_tag; }
 
 		// emitting
 		friend Emitter& operator << (Emitter& out, const Node& node);
@@ -108,36 +91,26 @@ namespace YAML
 
 		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_tag;
+		std::string m_anchor, m_tag;
 		Content *m_pContent;
 		bool m_alias;
 		const Node *m_pIdentity;
 		mutable bool m_referenced;
 	};
-	
-	// comparisons with auto-conversion
-	template <typename T>
-	bool operator == (const T& value, const Node& node);
-	
-	template <typename T>
-	bool operator == (const Node& node, const T& value);
-	
-	template <typename T>
-	bool operator != (const T& value, const Node& node);
-	
-	template <typename T>
-	bool operator != (const Node& node, const T& value);
-	
-	bool operator == (const char *value, const Node& node);
-	bool operator == (const Node& node, const char *value);
-	bool operator != (const char *value, const Node& node);
-	bool operator != (const Node& node, const char *value);
 }
 
 #include "nodeimpl.h"
-#include "nodereadimpl.h"
 
 #endif // NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/nodeimpl.h

@@ -9,6 +9,15 @@
 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;
@@ -16,14 +25,9 @@ namespace YAML
 		return value;
 	}
 	
-	template <typename T>
-	Node::operator T() const {
-		return Read<T>();
-	}
-
 	template <typename T>
 	inline void operator >> (const Node& node, T& value) {
-		if(!ConvertScalar(node, value))
+		if(!node.Read(value))
 			throw InvalidScalar(node.m_mark);
 	}
 	
@@ -76,43 +80,6 @@ namespace YAML
 	inline const Node& Node::operator [] (const char *key) const {
 		return GetValue(std::string(key));
 	}
-
-	template <typename T>
-	inline bool operator == (const T& value, const Node& node) {
-		return value == node.operator T();
-	}
-	
-	template <typename T>
-	inline bool operator == (const Node& node, const T& value) {
-		return value == node.operator T();
-	}
-	
-	template <typename T>
-	inline bool operator != (const T& value, const Node& node) {
-		return value != node.operator T();
-	}
-	
-	template <typename T>
-	inline bool operator != (const Node& node, const T& value) {
-		return value != node.operator T();
-	}
-
-	inline bool operator == (const char *value, const Node& node) {
-		return std::string(value) == node;
-	}
-	
-	inline bool operator == (const Node& node, const char *value) {
-		return std::string(value) == node;
-	}
-	
-	inline bool operator != (const char *value, const Node& node) {
-		return std::string(value) != node;
-	}
-	
-	inline bool operator != (const Node& node, const char *value) {
-		return std::string(value) != node;
-	}
-	
 }
 
 #endif // NODEIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/nodeproperties.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#ifndef NODEPROPERTIES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODEPROPERTIES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-namespace YAML
-{
-	struct NodeProperties {
-		std::string tag;
-		std::string anchor;
-	};
-}
-
-#endif // NODEPROPERTIES_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/nodereadimpl.h

@@ -1,78 +0,0 @@
-#pragma once
-
-namespace YAML
-{
-	// implementation for Node::Read
-	// (the goal is to call ConvertScalar if we can, and fall back to operator >> if not)
-	// thanks to litb from stackoverflow.com
-	// http://stackoverflow.com/questions/1386183/how-to-call-a-templated-function-if-it-exists-and-something-else-otherwise/1386390#1386390
-
-	// Note: this doesn't work on gcc 3.2, but does on gcc 3.4 and above. I'm not sure about 3.3.
-	
-#if __GNUC__ && (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ <= 3))
-	// trick doesn't work? Just fall back to ConvertScalar.
-	// This means that we can't use any user-defined types as keys in a map
-	template <typename T>
-	inline bool Node::Read(T& value) const {
-		return ConvertScalar(*this, value);
-	}
-#else
-	// usual case: the trick!
-	template<bool>
-	struct read_impl;
-	
-	// ConvertScalar available
-	template<>
-	struct read_impl<true> {
-		template<typename T>
-		static bool read(const Node& node, T& value) {
-			return ConvertScalar(node, value);
-		}
-	};
-
-	// ConvertScalar not available
-	template<>
-	struct read_impl<false> {
-		template<typename T>
-		static bool read(const Node& node, T& value) {
-			try {
-				node >> value;
-			} catch(const Exception&) {
-				return false;
-			}
-			return true;
-		}
-	};
-	
-	namespace fallback {
-		// sizeof > 1
-		struct flag { char c[2]; };
-		flag Convert(...);
-		
-		int operator,(flag, flag);
-		
-		template<typename T>
-		char operator,(flag, T const&);
-		
-		char operator,(int, flag);
-		int operator,(char, flag);
-	}
-
-	template <typename T>
-	inline bool Node::Read(T& value) const {
-		using namespace fallback;
-
-		return read_impl<sizeof (fallback::flag(), Convert(std::string(), value), fallback::flag()) != 1>::read(*this, value);
-	}
-#endif // done with trick
-	
-	// the main conversion function
-	template <typename T>
-	inline bool ConvertScalar(const Node& node, T& value) {
-		std::string scalar;
-		if(!node.GetScalar(scalar))
-			return false;
-		
-		return Convert(scalar, value);
-	}
-}

include/parser.h

@@ -4,55 +4,44 @@
 #define PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
 
-#include "graphbuilder.h"
-#include "noncopyable.h"
 #include <ios>
-#include <memory>
+#include <string>
+#include <vector>
+#include <map>
+#include "node.h"
+#include "parserstate.h"
 
 namespace YAML
 {
-	struct Directives;
-	struct Mark;
-	struct Token;
-	class EventHandler;
-	class GraphBuilderInterface;
-	class Node;
 	class Scanner;
+	struct Token;
 
-	class Parser: private noncopyable
+	class Parser
 	{
 	public:
-		Parser();
 		Parser(std::istream& in);
 		~Parser();
 
 		operator bool() const;
 
 		void Load(std::istream& in);
-		bool HandleNextDocument(EventHandler& eventHandler);
-		
-		void *BuildNextDocumentGraph(GraphBuilderInterface& graphBuilder);
-		template <class Builder>
-		typename Builder::Node *BuildNextDocumentGraph(Builder& graphBuilder)
-		{
-			GraphBuilder<Builder> wrapper(graphBuilder); // Must be lvalue to make C++ happy
-			return static_cast<typename Builder::Node *>(
-				BuildNextDocumentGraph(wrapper.AsBuilderInterface())
-			);
-		}
-		
-		bool GetNextDocument(Node& document);
+		void GetNextDocument(Node& document);
 		void PrintTokens(std::ostream& out);
 
 	private:
 		void ParseDirectives();
-		void HandleDirective(const Token& token);
-		void HandleYamlDirective(const Token& token);
-		void HandleTagDirective(const Token& token);
-		
+		void HandleDirective(Token *pToken);
+		void HandleYamlDirective(Token *pToken);
+		void HandleTagDirective(Token *pToken);
+
 	private:
-		std::auto_ptr<Scanner> m_pScanner;
-		std::auto_ptr<Directives> m_pDirectives;
+		// can't copy this
+		Parser(const Parser&) {}
+		Parser& operator = (const Parser&) { return *this; }
+
+	private:
+		Scanner *m_pScanner;
+		ParserState m_state;
 	};
 }
 

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

@@ -1,36 +0,0 @@
-#pragma once
-
-#ifndef STLNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define STLNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include <vector>
-#include <map>
-
-namespace YAML
-{
-	template <typename T>
-	void operator >> (const Node& node, std::vector<T>& v)
-	{
-		v.clear();
-		v.resize(node.size());
-		for(unsigned i=0;i<node.size();++i)
-			node[i] >> v[i];
-	}
-	
-	
-	template <typename K, typename V>
-	void operator >> (const Node& node, std::map<K, V>& m)
-	{
-		m.clear();
-		for(Iterator it=node.begin();it!=node.end();++it) {
-			K k;
-			V v;
-			it.first() >> k;
-			it.second() >> v;
-			m[k] = v;
-		}
-	}
-}
-
-#endif // STLNODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/traits.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-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 }; };
-	template <> struct is_numeric <long long> { enum { value = true }; };
-	template <> struct is_numeric <unsigned long long> { enum { value = true }; };
-	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.h

@@ -4,9 +4,9 @@
 #define YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
 
+#include "crt.h"
 #include "parser.h"
 #include "node.h"
-#include "stlnode.h"
 #include "iterator.h"
 #include "emitter.h"
 #include "stlemitter.h"

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

@@ -16,4 +16,4 @@ 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.
+THE SOFTWARE.

src/aliascontent.cpp

@@ -1,11 +1,27 @@
+#include "crt.h"
 #include "aliascontent.h"
 
 namespace YAML
 {
-	AliasContent::AliasContent(Content* pNodeContent): m_pRef(pNodeContent)
+	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);
@@ -56,11 +72,6 @@ namespace YAML
 		return m_pRef->GetScalar(scalar);
 	}
 
-	void AliasContent::EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const
-	{
-		m_pRef->EmitEvents(am, eventHandler, mark, tag, anchor);
-	}
-
 	int AliasContent::Compare(Content *pContent)
 	{
 		return m_pRef->Compare(pContent);

src/aliascontent.h

@@ -12,6 +12,11 @@ namespace YAML
 	{
 	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;
@@ -24,7 +29,6 @@ namespace YAML
 		virtual bool IsSequence() const;
 
 		virtual bool GetScalar(std::string& s) const;
-		virtual void EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const;
 
 		virtual int Compare(Content *);
 		virtual int Compare(Scalar *);

src/aliasmanager.cpp

@@ -1,45 +0,0 @@
-#include "aliasmanager.h"
-#include "node.h"
-#include <cassert>
-#include <sstream>
-
-namespace YAML
-{
-	AliasManager::AliasManager(): m_curAnchor(0)
-	{
-	}
-
-	void AliasManager::RegisterReference(const Node& node)
-	{
-		const Node *pIdentity = node.Identity();
-		m_newIdentityByOldIdentity.insert(std::make_pair(pIdentity, &node));
-		m_anchorByIdentity.insert(std::make_pair(&node, _CreateNewAnchor()));
-	}
-	
-	const Node *AliasManager::LookupReference(const Node& node) const
-	{
-		const Node *pIdentity = node.Identity();
-		return _LookupReference(*pIdentity);
-	}
-	
-	anchor_t AliasManager::LookupAnchor(const Node& node) const
-	{
-		AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(&node);
-		if(it == m_anchorByIdentity.end())
-			assert(false); // TODO: throw
-		return it->second;
-	}
-
-	const Node *AliasManager::_LookupReference(const Node& oldIdentity) const
-	{
-		NodeByNode::const_iterator it = m_newIdentityByOldIdentity.find(&oldIdentity);
-		if(it == m_newIdentityByOldIdentity.end())
-			return 0;
-		return it->second;
-	}
-	
-	anchor_t AliasManager::_CreateNewAnchor()
-	{
-		return ++m_curAnchor;
-	}
-}

src/collectionstack.h

@@ -1,33 +0,0 @@
-#pragma once
-
-#ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#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

@@ -1,21 +1,13 @@
+#include "crt.h"
 #include "content.h"
-#include "node.h"
-#include <cassert>
 
 namespace YAML
 {
-	void Content::SetData(const std::string&)
+	Content::Content()
 	{
-		assert(false); // TODO: throw
 	}
 
-	void Content::Append(std::auto_ptr<Node>)
+	Content::~Content()
 	{
-		assert(false); // TODO: throw
-	}
-
-	void Content::Insert(std::auto_ptr<Node>, std::auto_ptr<Node>)
-	{
-		assert(false); // TODO: throw
 	}
 }

src/content.h

@@ -4,30 +4,32 @@
 #define CONTENT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 
 
-#include "anchor.h"
+#include <vector>
+#include <map>
+#include "parserstate.h"
 #include "exceptions.h"
 #include "ltnode.h"
-#include <map>
-#include <memory>
-#include <vector>
 
 namespace YAML
 {
-	struct Mark;
-	struct NodeProperties;
-	class AliasManager;
-	class EventHandler;
-	class Map;
+	class Scanner;
+	class Parser;
 	class Node;
 	class Scalar;
-	class Scanner;
 	class Sequence;
+	class Map;
+	class Emitter;
 
 	class Content
 	{
 	public:
-		Content() {}
-		virtual ~Content() {}
+		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; }
@@ -38,11 +40,6 @@ namespace YAML
 		virtual bool IsScalar() const { return false; }
 		virtual bool IsMap() const { return false; }
 		virtual bool IsSequence() const { return false; }
-		
-		virtual void SetData(const std::string& data);
-		virtual void Append(std::auto_ptr<Node> pNode);
-		virtual void Insert(std::auto_ptr<Node> pKey, std::auto_ptr<Node> pValue);
-		virtual void EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const = 0;
 
 		// extraction
 		virtual bool GetScalar(std::string&) const { return false; }

src/conversion.cpp

@@ -49,7 +49,8 @@ namespace
 
 namespace YAML
 {
-	bool Convert(const std::string& input, bool& b)
+	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
@@ -81,7 +82,8 @@ namespace YAML
 		return false;
 	}
 	
-	bool Convert(const std::string& input, _Null& /*output*/)
+	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,27 +0,0 @@
-#pragma once
-
-#ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#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/emitfromevents.cpp

@@ -1,106 +0,0 @@
-#include "emitfromevents.h"
-#include "emitter.h"
-#include "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 std::string& tag, anchor_t anchor)
-	{
-		BeginNode();
-		EmitProps(tag, anchor);
-		if(tag.empty())
-			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())
-			m_emitter << VerbatimTag(tag);
-		if(anchor)
-			m_emitter << Anchor(ToString(anchor));
-	}
-}

src/emitter.cpp

@@ -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);
@@ -120,9 +115,6 @@ namespace YAML
 			case Value:
 				EmitValue();
 				break;
-			case TagByKind:
-				EmitKindTag();
-				break;
 			default:
 				m_pState->SetLocalValue(value);
 				break;
@@ -149,8 +141,6 @@ namespace YAML
 		switch(curState) {
 				// document-level
 			case ES_WAITING_FOR_DOC:
-				m_stream << "---";
-				m_pState->RequireSeparation();
 				m_pState->SwitchState(ES_WRITING_DOC);
 				return true;
 			case ES_WRITING_DOC:
@@ -328,10 +318,7 @@ 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(curState == ES_WRITING_BLOCK_SEQ_ENTRY || curState == ES_WRITING_BLOCK_MAP_KEY || curState == ES_WRITING_BLOCK_MAP_VALUE) {
 				m_stream << "\n";
 				m_pState->UnsetSeparation();
 			}
@@ -357,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);
 		
@@ -396,10 +373,7 @@ 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(curState == ES_WRITING_BLOCK_SEQ_ENTRY || curState == ES_WRITING_BLOCK_MAP_KEY || curState == ES_WRITING_BLOCK_MAP_VALUE) {
 				m_stream << "\n";
 				m_pState->UnsetSeparation();
 			}
@@ -425,21 +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);
-			m_stream << "}";
 		} else
 			assert(false);
 		
@@ -520,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)) {
@@ -536,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;
@@ -552,12 +516,24 @@ namespace YAML
 		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;
@@ -565,18 +541,18 @@ namespace YAML
 			case Hex:
 				str << std::hex;
 				break;
-				case Oct:
+			case Oct:
 				str << std::oct;
 				break;
 			default:
 				assert(false);
 		}
-	}
-	
-	void Emitter::PostWriteIntegralType(const std::stringstream& str)
-	{
+		
+		str << i;
 		m_stream << str.str();
+		
 		PostAtomicWrite();
+		return *this;
 	}
 	
 	Emitter& Emitter::Write(bool b)
@@ -618,6 +594,38 @@ namespace YAML
 		return *this;
 	}
 
+	Emitter& Emitter::Write(float f)
+	{
+		if(!good())
+			return *this;
+		
+		PreAtomicWrite();
+		EmitSeparationIfNecessary();
+		
+		std::stringstream str;
+		str << f;
+		m_stream << str.str();
+		
+		PostAtomicWrite();
+		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)
 	{
 		if(!good())
@@ -649,33 +657,6 @@ namespace YAML
 		return *this;
 	}
 	
-	Emitter& Emitter::Write(const _Tag& tag)
-	{
-		if(!good())
-			return *this;
-		
-		EmitTag(tag.verbatim, tag);
-		return *this;
-	}
-	
-	void Emitter::EmitTag(bool verbatim, const _Tag& tag)
-	{
-		PreAtomicWrite();
-		EmitSeparationIfNecessary();
-		if(!Utils::WriteTag(m_stream, tag.content, verbatim)) {
-			m_pState->SetError(ErrorMsg::INVALID_TAG);
-			return;
-		}
-		m_pState->RequireSeparation();
-		// Note: no PostAtomicWrite() because we need another value for this node
-	}
-	
-	void Emitter::EmitKindTag()
-	{
-		_Tag tag("");
-		EmitTag(false, tag);
-	}
-
 	Emitter& Emitter::Write(const _Comment& comment)
 	{
 		if(!good())
@@ -698,4 +679,3 @@ namespace YAML
 		return *this;
 	}
 }
-

src/emitterstate.cpp

@@ -9,7 +9,6 @@ namespace YAML
 		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);
@@ -44,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);
@@ -134,18 +132,6 @@ namespace YAML
 	{
 		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)
 	{

src/emitterstate.h

@@ -108,9 +108,6 @@ namespace YAML
 		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(); }
 		
@@ -152,7 +149,6 @@ namespace YAML
 		// other state
 		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;

src/emitterutils.cpp

@@ -11,125 +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) {
+			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;
 				
@@ -138,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;
@@ -252,15 +95,11 @@ 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;
 		}
@@ -269,15 +108,11 @@ namespace YAML
 		{
 			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;
 		}
@@ -285,32 +120,24 @@ 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)
+			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 << buffer[0];
-					++buffer;
-				}
+				
+				out << str[i];
 			}
-			if (verbatim)
-				out << ">";
 			return true;
 		}
 	}

src/emitterutils.h

@@ -11,14 +11,13 @@ namespace YAML
 {
 	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 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);
 	}
 }
 

src/exp.cpp

@@ -1,3 +1,4 @@
+#include "crt.h"
 #include "exp.h"
 #include "exceptions.h"
 #include <sstream>
@@ -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);

src/exp.h

@@ -17,153 +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& 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) + Blank()));
-			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_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);
@@ -182,8 +74,6 @@ namespace YAML
 		const char Tag = '!';
 		const char LiteralScalar = '|';
 		const char FoldedScalar = '>';
-		const char VerbatimTagStart = '<';
-		const char VerbatimTagEnd = '>';
 	}
 }
 

src/graphbuilderadapter.cpp

@@ -1,96 +0,0 @@
-#include "graphbuilderadapter.h"
-
-namespace YAML
-{
-  int GraphBuilderAdapter::ContainerFrame::sequenceMarker;
-  
-  void GraphBuilderAdapter::OnNull(const std::string& tag, anchor_t anchor)
-  {
-    void *pParent = GetCurrentParent();
-    void *pNode = m_builder.NewNull(tag, 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/graphbuilderadapter.h

@@ -1,68 +0,0 @@
-#ifndef GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include <map>
-#include <stack>
-#include "anchordict.h"
-#include "eventhandler.h"
-#include "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 std::string& tag, 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/iterator.cpp

@@ -1,3 +1,4 @@
+#include "crt.h"
 #include "node.h"
 #include "exceptions.h"
 #include "iterpriv.h"

src/map.cpp

@@ -1,13 +1,26 @@
+#include "crt.h"
 #include "map.h"
 #include "node.h"
-#include "eventhandler.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()
 	{
@@ -23,6 +36,11 @@ namespace YAML
 		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();
@@ -35,28 +53,106 @@ namespace YAML
 		return true;
 	}
 
-	std::size_t Map::GetSize() const
+	void Map::Parse(Scanner *pScanner, const ParserState& state)
 	{
-		return m_data.size();
-	}
+		Clear();
 
-	void Map::Insert(std::auto_ptr<Node> pKey, std::auto_ptr<Node> pValue)
-	{
-		node_map::const_iterator it = m_data.find(pKey.get());
-		if(it != m_data.end())
-			return;
-		
-		m_data[pKey.release()] = pValue.release();
-	}
-
-	void Map::EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const
-	{
-		eventHandler.OnMapStart(mark, tag, anchor);
-		for(node_map::const_iterator it=m_data.begin();it!=m_data.end();++it) {
-			it->first->EmitEvents(am, eventHandler);
-			it->second->EmitEvents(am, eventHandler);
+		// 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;
 		}
-		eventHandler.OnMapEnd();
+	}
+
+	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)

src/map.h

@@ -6,7 +6,6 @@
 
 #include "content.h"
 #include <map>
-#include <memory>
 
 namespace YAML
 {
@@ -19,16 +18,16 @@ namespace YAML
 
 	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 std::size_t GetSize() const;
-
-		virtual void Insert(std::auto_ptr<Node> pKey, std::auto_ptr<Node> pValue);
-		virtual void EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const;
+		virtual void Parse(Scanner *pScanner, const ParserState& state);
+		virtual void Write(Emitter& out) const;
 
 		virtual bool IsMap() const { return true; }
 
@@ -38,6 +37,10 @@ namespace YAML
 		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;
 	};

src/node.cpp

@@ -1,21 +1,15 @@
+#include "crt.h"
 #include "node.h"
-#include "aliascontent.h"
-#include "aliasmanager.h"
-#include "content.h"
-#include "emitfromevents.h"
-#include "emitter.h"
-#include "eventhandler.h"
-#include "graphbuilderadapter.h"
-#include "iterpriv.h"
-#include "map.h"
-#include "nodebuilder.h"
-#include "nodeproperties.h"
-#include "scalar.h"
-#include "scanner.h"
-#include "sequence.h"
-#include "tag.h"
 #include "token.h"
-#include <cassert>
+#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
@@ -26,10 +20,17 @@ namespace YAML
 		return *pNode1 < *pNode2;
 	}
 
-	Node::Node(): m_pContent(0), m_alias(false), m_pIdentity(this), m_referenced(false)
+	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();
@@ -41,107 +42,131 @@ namespace YAML
 		m_pContent = 0;
 		m_alias = false;
 		m_referenced = false;
+		m_anchor.clear();
 		m_tag.clear();
 	}
 	
 	std::auto_ptr<Node> Node::Clone() const
 	{
-		std::auto_ptr<Node> pNode(new Node);
-		NodeBuilder nodeBuilder(*pNode);
-		GraphBuilder<NodeBuilder> graphBuilder(nodeBuilder);
-		GraphBuilderAdapter eventHandler(graphBuilder);
-		EmitEvents(eventHandler);
-		return pNode;
-	}
-
-	void Node::EmitEvents(EventHandler& eventHandler) const
-	{
-		eventHandler.OnDocumentStart(m_mark);
-		AliasManager am;
-		EmitEvents(am, eventHandler);
-		eventHandler.OnDocumentEnd();
-	}
-
-	void Node::EmitEvents(AliasManager& am, EventHandler& eventHandler) const
-	{
-		anchor_t anchor = NullAnchor;
-		if(m_referenced || m_alias) {
-			if(const Node *pOther = am.LookupReference(*this)) {
-				eventHandler.OnAlias(m_mark, am.LookupAnchor(*pOther));
-				return;
-			}
-			
-			am.RegisterReference(*this);
-			anchor = am.LookupAnchor(*this);
-		}
+		if(m_alias)
+			throw std::runtime_error("yaml-cpp: Can't clone alias");  // TODO: what to do about aliases?
 		
-		if(m_pContent)
-			m_pContent->EmitEvents(am, eventHandler, m_mark, GetTag(), anchor);
-		else
-			eventHandler.OnNull(GetTag(), anchor);
+		return std::auto_ptr<Node> (new Node(m_mark, m_anchor, m_tag, m_pContent));
 	}
 
-	void Node::Init(CONTENT_TYPE type, const Mark& mark, const std::string& tag)
+	void Node::Parse(Scanner *pScanner, const ParserState& state)
 	{
 		Clear();
-		m_mark = mark;
-		m_tag = tag;
-		m_alias = false;
-		m_pIdentity = this;
-		m_referenced = false;
 
-		switch(type) {
-			case CT_SCALAR:
+		// 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 CT_SEQUENCE:
+			case Token::FLOW_SEQ_START:
+			case Token::BLOCK_SEQ_START:
 				m_pContent = new Sequence;
 				break;
-			case CT_MAP:
+			case Token::FLOW_MAP_START:
+			case Token::BLOCK_MAP_START:
 				m_pContent = new Map;
 				break;
 			default:
-				m_pContent = 0;
+//				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::InitNull(const std::string& tag)
+	void Node::ParseTag(Scanner *pScanner, const ParserState& state)
 	{
-		Clear();
-		m_tag = tag;
-		m_alias = false;
-		m_pIdentity = this;
-		m_referenced = false;
-	}
+		Token& token = pScanner->peek();
+		if(m_tag != "")
+			throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS);
 
-	void Node::InitAlias(const Mark& mark, const Node& identity)
-	{
-		Clear();
-		m_mark = mark;
-		m_alias = true;
-		m_pIdentity = &identity;
-		if(identity.m_pContent)
-			m_pContent = new AliasContent(identity.m_pContent);
-		identity.m_referenced = true;
-	}
+		m_tag = state.TranslateTag(token.value);
 
-	void Node::SetData(const std::string& data)
-	{
-		assert(m_pContent); // TODO: throw
-		m_pContent->SetData(data);
-	}
-
-	void Node::Append(std::auto_ptr<Node> pNode)
-	{
-		assert(m_pContent); // TODO: throw
-		m_pContent->Append(pNode);
+		for(std::size_t i=0;i<token.params.size();i++)
+			m_tag += token.params[i];
+		pScanner->pop();
 	}
 	
-	void Node::Insert(std::auto_ptr<Node> pKey, std::auto_ptr<Node> pValue)
+	void Node::ParseAnchor(Scanner *pScanner, const ParserState& /*state*/)
 	{
-		assert(m_pContent); // TODO: throw
-		m_pContent->Insert(pKey, pValue);
+		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
@@ -217,10 +242,7 @@ namespace YAML
 	bool Node::GetScalar(std::string& s) const
 	{
 		if(!m_pContent) {
-			if(m_tag.empty())
-				s = "~";
-			else
-				s = "";
+			s = "~";
 			return true;
 		}
 		
@@ -229,8 +251,22 @@ namespace YAML
 
 	Emitter& operator << (Emitter& out, const Node& node)
 	{
-		EmitFromEvents emitFromEvents(out);
-		node.EmitEvents(emitFromEvents);
+		// 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;
 	}
 

src/nodebuilder.cpp

@@ -1,90 +0,0 @@
-#include "nodebuilder.h"
-#include "mark.h"
-#include "node.h"
-#include "nodeproperties.h"
-#include <cassert>
-
-namespace YAML
-{
-	NodeBuilder::NodeBuilder(Node& root): m_root(root), m_initializedRoot(false)
-	{
-		m_root.Clear();
-	}
-	
-	NodeBuilder::NodeBuilder(const NodeBuilder& o): m_root(o.m_root), m_initializedRoot(o.m_initializedRoot)
-	{
-	}
-	
-	NodeBuilder::~NodeBuilder()
-	{
-	}
-
-	Node *NodeBuilder::NewNull(const std::string& tag, Node *pParent)
-	{
-		(void)pParent;
-		Node *pNode = NewNode();
-		pNode->InitNull(tag);
-		return pNode;
-	}
-
-	Node *NodeBuilder::AnchorReference(const Mark& mark, Node *pNode)
-	{
-		Node *pAlias = NewNode();
-		pAlias->InitAlias(mark, *pNode);
-		return pAlias;
-	}
-
-	Node *NodeBuilder::NewScalar(const Mark& mark, const std::string& tag, Node *pParent, const std::string& value)
-	{
-		(void)pParent;
-		Node *pNode = NewNode();
-		pNode->Init(CT_SCALAR, mark, tag);
-		pNode->SetData(value);
-		return pNode;
-	}
-
-	NodeBuilder::Sequence *NodeBuilder::NewSequence(const Mark& mark, const std::string& tag, Node *pParent)
-	{
-		(void)pParent;
-		Node *pNode = NewNode();
-		pNode->Init(CT_SEQUENCE, mark, tag);
-		return pNode;
-	}
-
-	void NodeBuilder::AppendToSequence(Sequence *pSequence, Node *pNode)
-	{
-		std::auto_ptr<Node> apNode(m_unlinked.pop(pNode));
-		assert(apNode.get());
-		pSequence->Append(apNode);
-	}
-
-	NodeBuilder::Map *NodeBuilder::NewMap(const Mark& mark, const std::string& tag, Node* pParent)
-	{
-		(void)pParent;
-		Node *pNode = NewNode();
-		pNode->Init(CT_MAP, mark, tag);
-		return pNode;
-	}
-
-	void NodeBuilder::AssignInMap(Map *pMap, Node *pKeyNode, Node *pValueNode)
-	{
-		std::auto_ptr<Node> apKeyNode(m_unlinked.pop(pKeyNode));
-		std::auto_ptr<Node> apValueNode(m_unlinked.pop(pValueNode));
-		assert(apKeyNode.get() && apValueNode.get());
-		pMap->Insert(apKeyNode, apValueNode);
-	}
-	
-	Node* NodeBuilder::NewNode()
-	{
-		if(!m_initializedRoot) {
-			m_initializedRoot = true;
-			return &m_root;
-		}
-		
-		std::auto_ptr<Node> pNode(new Node);
-		Node* pResult = pNode.get();
-		// Save the pointer in a collection that will free it on exception
-		m_unlinked.push(pNode);
-		return pResult;
-	}
-}

src/nodebuilder.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#ifndef NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include <map>
-#include <memory>
-#include <stack>
-#include <string>
-
-#include "ptr_stack.h"
-
-namespace YAML
-{
-	class Node;
-	class Mark;
-	
-	class NodeBuilder
-	{
-	public:
-		typedef YAML::Node Node;
-		typedef YAML::Node Map;
-		typedef YAML::Node Sequence;
-		
-		explicit NodeBuilder(Node& root);
-		NodeBuilder(const NodeBuilder& o);
-		virtual ~NodeBuilder();
-
-		Node *NewNull(const std::string& tag, Node *pParent);
-		Node *AnchorReference(const Mark& mark, Node *pNode);
-		Node *NewScalar(const Mark& mark, const std::string& tag, Node *pParent, const std::string& value);
-		
-		Sequence *NewSequence(const Mark& mark, const std::string& tag, Node *pParent);
-		void AppendToSequence(Sequence *pSequence, Node *pNode);
-		void SequenceComplete(Sequence *pSequence) {(void)pSequence;}
-		
-		Map *NewMap(const Mark& mark, const std::string& tag, Node *pParent);
-		void AssignInMap(Map *pMap, Node *pKeyNode, Node *pValueNode);
-		void MapComplete(Map *pMap) {(void)pMap;}
-		
-	private:
-		Node* NewNode();
-		
-	private:
-		Node& m_root;
-		bool m_initializedRoot;
-		
-		ptr_stack<Node> m_unlinked;
-	};
-}
-
-#endif // NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/parser.cpp

@@ -1,81 +1,63 @@
+#include "crt.h"
 #include "parser.h"
-#include "directives.h"
-#include "eventhandler.h"
-#include "exceptions.h"
-#include "graphbuilderadapter.h"
-#include "node.h"
-#include "nodebuilder.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);
-	}
-
-	// HandleNextDocument
-	// . Handles the next document
-	// . Throws a ParserException on error.
-	// . Returns false if there are no more documents
-	bool Parser::HandleNextDocument(EventHandler& eventHandler)
-	{
-		if(!m_pScanner.get())
-			return false;
-
-		ParseDirectives();
-		if(m_pScanner->empty())
-			return false;
-		
-		SingleDocParser sdp(*m_pScanner, *m_pDirectives);
-		sdp.HandleDocument(eventHandler);
-		return true;
-	}
-	
-	// BuildNextDocumentGraph
-	// . Builds a graph of the next document
-	// . Returns NULL if there are no more documents
-	void *Parser::BuildNextDocumentGraph(GraphBuilderInterface& graphBuilder)
-	{
-		GraphBuilderAdapter eventHandler(graphBuilder);
-		if (HandleNextDocument(eventHandler)) {
-			return eventHandler.RootNode();
-		} else {
-			return NULL;
-		}
+		delete m_pScanner;
+		m_pScanner = new Scanner(in);
+		m_state.Reset();
 	}
 
 	// GetNextDocument
 	// . Reads the next document in the queue (of tokens).
 	// . Throws a ParserException on error.
-	bool Parser::GetNextDocument(Node& document)
+	void Parser::GetNextDocument(Node& document)
 	{
-		NodeBuilder builder(document);
-		return BuildNextDocumentGraph(builder);
+		// clear node
+		document.Clear();
+
+		// first read directives
+		ParseDirectives();
+
+		// we better have some tokens in the queue
+		if(m_pScanner->empty())
+			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
@@ -95,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, 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,55 +0,0 @@
-#pragma once
-
-#ifndef PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-#include "noncopyable.h"
-
-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) {
-		// Make sure that the space is available before releasing the
-		// auto_ptr to it.  NULL can be deleted safely.
-		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;
-	}
-	std::auto_ptr<T> pop(T* val) {
-		typename std::vector<T*>::reverse_iterator itVal =
-		  std::find(m_data.rbegin(), m_data.rend(), val);
-		std::auto_ptr<T> t;
-		if (itVal != m_data.rend()) {
-			t.reset(*itVal);
-			m_data.erase((itVal + 1).base());
-		}
-		return t;
-	}
-	T& top() const { return *m_data.back(); }
-	
-private:
-	std::vector<T*> m_data;
-};
-
-#endif // PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/regex.cpp

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

src/regex.h

@@ -37,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/scalar.cpp

@@ -1,5 +1,10 @@
+#include "crt.h"
 #include "scalar.h"
-#include "eventhandler.h"
+#include "scanner.h"
+#include "token.h"
+#include "exceptions.h"
+#include "node.h"
+#include "emitter.h"
 
 namespace YAML
 {
@@ -7,13 +12,29 @@ namespace YAML
 	{
 	}
 
+	Scalar::Scalar(const std::string& data): m_data(data)
+	{
+	}
+
 	Scalar::~Scalar()
 	{
 	}
 
-	void Scalar::EmitEvents(AliasManager&, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const
+	Content *Scalar::Clone() const
 	{
-		eventHandler.OnScalar(mark, tag, anchor, m_data);
+		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)

src/scalar.h

@@ -13,12 +13,15 @@ namespace YAML
 	{
 	public:
 		Scalar();
+		Scalar(const std::string& data);
 		virtual ~Scalar();
 
-		virtual void SetData(const std::string& data) { m_data = data; }
+		virtual Content *Clone() const;
+
+		virtual void Parse(Scanner *pScanner, const ParserState& state);
+		virtual void Write(Emitter& out) const;
 
 		virtual bool IsScalar() const { return true; }
-		virtual void EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const;
 
 		// extraction
 		virtual bool GetScalar(std::string& scalar) const {

src/scanner.cpp

@@ -1,22 +1,19 @@
+#include "crt.h"
 #include "scanner.h"
 #include "token.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)
 	{
 	}
 
 	Scanner::~Scanner()
 	{
-		for(unsigned i=0;i<m_indentRefs.size();i++)
-			delete m_indentRefs[i];
-		m_indentRefs.clear();
 	}
 
 	// empty
@@ -32,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
@@ -114,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
@@ -131,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
@@ -156,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!
@@ -169,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
@@ -203,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;
-		IndentMarker *pIndent = new IndentMarker(-1, IndentMarker::NONE);
-		m_indentRefs.push_back(pIndent);
-		m_indents.push(pIndent);
+		m_indents.push(IndentMarker(-1, IndentMarker::NONE));
+		m_anchors.clear();
 	}
 
 	// EndStream
@@ -257,22 +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);
-	}
-
 	// PushIndentTo
 	// . Pushes an indentation onto the stack, and enqueues the
 	//   proper token (sequence start or mapping start).
@@ -283,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)
@@ -294,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.release());
-		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?
@@ -314,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
@@ -338,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;
 			
@@ -350,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()));
 	}
 
@@ -369,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
@@ -385,5 +379,9 @@ namespace YAML
 		}
 		throw ParserException(mark, msg);
 	}
-}
 
+	void Scanner::ClearAnchors()
+	{
+		m_anchors.clear();
+	}
+}

src/scanner.h

@@ -16,7 +16,6 @@
 namespace YAML
 {
 	class Node;
-	class RegEx;
 
 	class Scanner
 	{
@@ -29,15 +28,19 @@ namespace YAML
 		void pop();
 		Token& peek();
 
+		// anchor management
+		void Save(const std::string& anchor, Node* value);
+		const Node *Retrieve(const std::string& anchor) const;
+		void ClearAnchors();
+
 	private:
 		struct IndentMarker {
 			enum INDENT_TYPE { MAP, SEQ, NONE };
-			enum STATUS { VALID, INVALID, UNKNOWN };
-			IndentMarker(int column_, INDENT_TYPE type_): column(column_), type(type_), status(VALID), pStartToken(0) {}
+			IndentMarker(int column_, INDENT_TYPE type_): column(column_), type(type_), isValid(true), pStartToken(0) {}
 		
 			int column;
 			INDENT_TYPE type;
-			STATUS status;
+			bool isValid;
 			Token *pStartToken;
 		};
 		
@@ -50,13 +53,11 @@ namespace YAML
 		void ScanToNextToken();
 		void StartStream();
 		void EndStream();
-		Token *PushToken(Token::TYPE type);
 		
 		bool InFlowContext() const { return !m_flows.empty(); }
 		bool InBlockContext() const { return m_flows.empty(); }
 		int GetFlowLevel() const { return m_flows.size(); }
 		
-		Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const;
 		IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type);
 		void PopIndentToHere();
 		void PopAllIndents();
@@ -74,7 +75,6 @@ namespace YAML
 		void ThrowParserException(const std::string& msg) const;
 
 		bool IsWhitespaceToBeEaten(char ch);
-		const RegEx& GetValueRegex() const;
 
 		struct SimpleKey {
 			SimpleKey(const Mark& mark_, int flowLevel_);
@@ -117,13 +117,11 @@ namespace YAML
 		// state info
 		bool m_startedStream, m_endedStream;
 		bool m_simpleKeyAllowed;
-		bool m_canBeJSONFlow;
 		std::stack <SimpleKey> m_simpleKeys;
-		std::stack <IndentMarker *> m_indents;
-		std::vector <IndentMarker *> m_indentRefs; // for "garbage collection"
+		std::stack <IndentMarker> m_indents;
 		std::stack <FLOW_MARKER> m_flows;
+		std::map <std::string, const Node *> m_anchors;
 	};
 }
 
 #endif // SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/scanscalar.cpp

@@ -1,3 +1,4 @@
+#include "crt.h"
 #include "scanscalar.h"
 #include "scanner.h"
 #include "exp.h"
@@ -18,26 +19,20 @@ namespace YAML
 	//   and different places in the above flow.
 	std::string ScanScalar(Stream& INPUT, ScanScalarParams& params)
 	{
-		bool foundNonEmptyLine = false;
-		bool pastOpeningBreak = (params.fold == FOLD_FLOW);
+		bool foundNonEmptyLine = false, pastOpeningBreak = false;
 		bool emptyLine = false, moreIndented = false;
-		int foldedNewlineCount = 0;
-		bool foldedNewlineStartedMoreIndented = false;
 		std::string scalar;
 		params.leadingSpaces = false;
 
 		while(INPUT) {
 			// ********************************
 			// Phase #1: scan until line ending
-			
-			std::size_t lastNonWhitespaceChar = scalar.size();
-			bool escapedNewline = false;
-			while(!params.end.Matches(INPUT) && !Exp::Break().Matches(INPUT)) {
+			while(!params.end.Matches(INPUT) && !Exp::Break.Matches(INPUT)) {
 				if(!INPUT)
 					break;
 
 				// document indicator?
-				if(INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) {
+				if(INPUT.column() == 0 && Exp::DocIndicator.Matches(INPUT)) {
 					if(params.onDocIndicator == BREAK)
 						break;
 					else if(params.onDocIndicator == THROW)
@@ -48,26 +43,20 @@ namespace YAML
 				pastOpeningBreak = true;
 
 				// escaped newline? (only if we're escaping on slash)
-				if(params.escape == '\\' && Exp::EscBreak().Matches(INPUT)) {
-					// eat escape character and get out (but preserve trailing whitespace!)
-					INPUT.get();
-					lastNonWhitespaceChar = scalar.size();
-					escapedNewline = true;
-					break;
+				if(params.escape == '\\' && Exp::EscBreak.Matches(INPUT)) {
+					int n = Exp::EscBreak.Match(INPUT);
+					INPUT.eat(n);
+					continue;
 				}
 
 				// escape this?
 				if(INPUT.peek() == params.escape) {
 					scalar += Exp::Escape(INPUT);
-					lastNonWhitespaceChar = scalar.size();
 					continue;
 				}
 
 				// otherwise, just add the damn character
-				char ch = INPUT.get();
-				scalar += ch;
-				if(ch != ' ' && ch != '\t')
-					lastNonWhitespaceChar = scalar.size();
+				scalar += INPUT.get();
 			}
 
 			// eof? if we're looking to eat something, then we throw
@@ -78,7 +67,7 @@ namespace YAML
 			}
 
 			// doc indicator?
-			if(params.onDocIndicator == BREAK && INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT))
+			if(params.onDocIndicator == BREAK && INPUT.column() == 0 && Exp::DocIndicator.Matches(INPUT))
 				break;
 
 			// are we done via character match?
@@ -88,14 +77,10 @@ namespace YAML
 					INPUT.eat(n);
 				break;
 			}
-			
-			// do we remove trailing whitespace?
-			if(params.fold == FOLD_FLOW)
-				scalar.erase(lastNonWhitespaceChar);
-			
+
 			// ********************************
 			// Phase #2: eat line ending
-			n = Exp::Break().Match(INPUT);
+			n = Exp::Break.Match(INPUT);
 			INPUT.eat(n);
 
 			// ********************************
@@ -110,7 +95,7 @@ namespace YAML
 				params.indent = std::max(params.indent, INPUT.column());
 
 			// and then the rest of the whitespace
-			while(Exp::Blank().Matches(INPUT)) {
+			while(Exp::Blank.Matches(INPUT)) {
 				// we check for tabs that masquerade as indentation
 				if(INPUT.peek() == '\t'&& INPUT.column() < params.indent && params.onTabInIndentation == THROW)
 					throw ParserException(INPUT.mark(), ErrorMsg::TAB_IN_INDENTATION);
@@ -122,39 +107,20 @@ namespace YAML
 			}
 
 			// was this an empty line?
-			bool nextEmptyLine = Exp::Break().Matches(INPUT);
-			bool nextMoreIndented = Exp::Blank().Matches(INPUT);
-			if(params.fold == FOLD_BLOCK && foldedNewlineCount == 0 && nextEmptyLine)
-				foldedNewlineStartedMoreIndented = moreIndented;
+			bool nextEmptyLine = Exp::Break.Matches(INPUT);
+			bool nextMoreIndented = (INPUT.peek() == ' ');
 
 			// for block scalars, we always start with a newline, so we should ignore it (not fold or keep)
-			if(pastOpeningBreak) {
-				switch(params.fold) {
-					case DONT_FOLD:
-						scalar += "\n";
-						break;
-					case FOLD_BLOCK:
-						if(!emptyLine && !nextEmptyLine && !moreIndented && !nextMoreIndented && INPUT.column() >= params.indent)
-							scalar += " ";
-						else if(nextEmptyLine)
-							foldedNewlineCount++;
-						else
-							scalar += "\n";
-						
-						if(!nextEmptyLine && foldedNewlineCount > 0) {
-							scalar += std::string(foldedNewlineCount - 1, '\n');
-							if(foldedNewlineStartedMoreIndented || nextMoreIndented)
-								scalar += "\n";
-							foldedNewlineCount = 0;
-						}
-						break;
-					case FOLD_FLOW:
-						if(nextEmptyLine)
-							scalar += "\n";
-						else if(!emptyLine && !nextEmptyLine && !escapedNewline)
-							scalar += " ";
-						break;
-				}
+			bool useNewLine = pastOpeningBreak;
+			// and for folded scalars, we don't fold the very last newline to a space
+			if(params.fold && !emptyLine && INPUT.column() < params.indent)
+				useNewLine = false;
+
+			if(useNewLine) {
+				if(params.fold && !emptyLine && !nextEmptyLine && !moreIndented && !nextMoreIndented)
+					scalar += " ";
+				else
+					scalar += "\n";
 			}
 
 			emptyLine = nextEmptyLine;
@@ -175,11 +141,11 @@ namespace YAML
 				scalar.erase(pos + 1);
 		}
 
-		if(params.chomp == STRIP || params.chomp == CLIP) {
+		if(params.chomp <= 0) {
 			std::size_t pos = scalar.find_last_not_of('\n');
-			if(params.chomp == CLIP && pos + 1 < scalar.size())
+			if(params.chomp == 0 && pos + 1 < scalar.size())
 				scalar.erase(pos + 2);
-			else if(params.chomp == STRIP && pos < scalar.size())
+			else if(params.chomp == -1 && pos < scalar.size())
 				scalar.erase(pos + 1);
 		}
 

src/scanscalar.h

@@ -12,10 +12,9 @@ namespace YAML
 {
 	enum CHOMP { STRIP = -1, CLIP, KEEP };
 	enum ACTION { NONE, BREAK, THROW };
-	enum FOLD { DONT_FOLD, FOLD_BLOCK, FOLD_FLOW };
 
 	struct ScanScalarParams {
-		ScanScalarParams(): eatEnd(false), indent(0), detectIndent(false), eatLeadingWhitespace(0), escape(0), fold(DONT_FOLD),
+		ScanScalarParams(): eatEnd(false), indent(0), detectIndent(false), eatLeadingWhitespace(0), escape(0), fold(false),
 			trimTrailingSpaces(0), chomp(CLIP), onDocIndicator(NONE), onTabInIndentation(NONE), leadingSpaces(false) {}
 
 		// input:
@@ -25,7 +24,7 @@ namespace YAML
 		bool detectIndent;              // should we try to autodetect the indent?
 		bool eatLeadingWhitespace;      // should we continue eating this delicious indentation after 'indent' spaces?
 		char escape;                    // what character do we escape on (i.e., slash or single quote) (0 for none)
-		FOLD fold;                      // how do we fold line ends?
+		bool fold;                      // do we fold line ends?
 		bool trimTrailingSpaces;        // do we remove all trailing spaces (at the very end)
 		CHOMP chomp;                    // do we strip, clip, or keep trailing newlines (at the very end)
 		                                //   Note: strip means kill all, clip means keep at most one, keep means keep all
@@ -40,4 +39,3 @@ namespace YAML
 }
 
 #endif // SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/scantag.cpp

@@ -1,84 +0,0 @@
-#include "scanner.h"
-#include "regex.h"
-#include "exp.h"
-#include "exceptions.h"
-
-namespace YAML
-{
-	const std::string ScanVerbatimTag(Stream& INPUT)
-	{
-		std::string tag;
-		
-		// eat the start character
-		INPUT.get();
-		
-		while(INPUT) {
-			if(INPUT.peek() == Keys::VerbatimTagEnd) {
-				// eat the end character
-				INPUT.get();
-				return tag;
-			}
-		
-			int n = Exp::URI().Match(INPUT);
-			if(n <= 0)
-				break;
-			
-			tag += INPUT.get(n);
-		}
-
-		throw ParserException(INPUT.mark(), ErrorMsg::END_OF_VERBATIM_TAG);
-	}
-	
-	const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle)
-	{
-		std::string tag;
-		canBeHandle = true;
-		Mark firstNonWordChar;
-		
-		while(INPUT) {
-			if(INPUT.peek() == Keys::Tag) {
-				if(!canBeHandle)
-					throw ParserException(firstNonWordChar, ErrorMsg::CHAR_IN_TAG_HANDLE);
-				break;
-			}
-
-			int n = 0;
-			if(canBeHandle) {
-				n = Exp::Word().Match(INPUT);
-				if(n <= 0) {
-					canBeHandle = false;
-					firstNonWordChar = INPUT.mark();
-				}
-			}
-			
-			if(!canBeHandle)
-				n = Exp::Tag().Match(INPUT);
-
-			if(n <= 0)
-				break;
-			
-			tag += INPUT.get(n);
-		}
-
-		return tag;
-	}
-	
-	const std::string ScanTagSuffix(Stream& INPUT)
-	{
-		std::string tag;
-		
-		while(INPUT) {
-			int n = Exp::Tag().Match(INPUT);
-			if(n <= 0)
-				break;
-			
-			tag += INPUT.get(n);
-		}
-		
-		if(tag.empty())
-			throw ParserException(INPUT.mark(), ErrorMsg::TAG_WITH_NO_SUFFIX);
-		
-		return tag;
-	}
-}
-

src/scantag.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#ifndef SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include <string>
-#include "stream.h"
-
-namespace YAML
-{
-	const std::string ScanVerbatimTag(Stream& INPUT);
-	const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle);
-	const std::string ScanTagSuffix(Stream& INPUT);
-}
-
-#endif // SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/scantoken.cpp

@@ -1,10 +1,9 @@
+#include "crt.h"
 #include "scanner.h"
 #include "token.h"
 #include "exceptions.h"
 #include "exp.h"
 #include "scanscalar.h"
-#include "scantag.h"
-#include "tag.h"
 #include <sstream>
 
 namespace YAML
@@ -24,34 +23,36 @@ namespace YAML
 		PopAllSimpleKeys();
 
 		m_simpleKeyAllowed = false;
-		m_canBeJSONFlow = false;
 
 		// store pos and eat indicator
-		Token token(Token::DIRECTIVE, INPUT.mark());
+		Mark mark = INPUT.mark();
 		INPUT.eat(1);
 
 		// read name
-		while(INPUT && !Exp::BlankOrBreak().Matches(INPUT))
-			token.value += INPUT.get();
+		while(INPUT && !Exp::BlankOrBreak.Matches(INPUT))
+			name += INPUT.get();
 
 		// read parameters
 		while(1) {
 			// first get rid of whitespace
-			while(Exp::Blank().Matches(INPUT))
+			while(Exp::Blank.Matches(INPUT))
 				INPUT.eat(1);
 
 			// break on newline or comment
-			if(!INPUT || Exp::Break().Matches(INPUT) || Exp::Comment().Matches(INPUT))
+			if(!INPUT || Exp::Break.Matches(INPUT) || Exp::Comment.Matches(INPUT))
 				break;
 
 			// now read parameter
 			std::string param;
-			while(INPUT && !Exp::BlankOrBreak().Matches(INPUT))
+			while(INPUT && !Exp::BlankOrBreak.Matches(INPUT))
 				param += INPUT.get();
 
-			token.params.push_back(param);
+			params.push_back(param);
 		}
 		
+		Token token(Token::DIRECTIVE, mark);
+		token.value = name;
+		token.params = params;
 		m_tokens.push(token);
 	}
 
@@ -61,7 +62,6 @@ namespace YAML
 		PopAllIndents();
 		PopAllSimpleKeys();
 		m_simpleKeyAllowed = false;
-		m_canBeJSONFlow = false;
 
 		// eat
 		Mark mark = INPUT.mark();
@@ -75,7 +75,6 @@ namespace YAML
 		PopAllIndents();
 		PopAllSimpleKeys();
 		m_simpleKeyAllowed = false;
-		m_canBeJSONFlow = false;
 
 		// eat
 		Mark mark = INPUT.mark();
@@ -89,7 +88,6 @@ namespace YAML
 		// flows can be simple keys
 		InsertPotentialSimpleKey();
 		m_simpleKeyAllowed = true;
-		m_canBeJSONFlow = false;
 
 		// eat
 		Mark mark = INPUT.mark();
@@ -107,15 +105,10 @@ namespace YAML
 			throw ParserException(INPUT.mark(), ErrorMsg::FLOW_END);
 
 		// we might have a solo entry in the flow context
-		if(InFlowContext()) {
-			if(m_flows.top() == FLOW_MAP && VerifySimpleKey())
-				m_tokens.push(Token(Token::VALUE, INPUT.mark()));
-			else if(m_flows.top() == FLOW_SEQ)
-				InvalidateSimpleKey();
-		}
+		if(VerifySimpleKey())
+			m_tokens.push(Token(Token::VALUE, INPUT.mark()));
 
 		m_simpleKeyAllowed = false;
-		m_canBeJSONFlow = true;
 
 		// eat
 		Mark mark = INPUT.mark();
@@ -134,16 +127,11 @@ namespace YAML
 	// FlowEntry
 	void Scanner::ScanFlowEntry()
 	{
-		// we might have a solo entry in the flow context
-		if(InFlowContext()) {
-			if(m_flows.top() == FLOW_MAP && VerifySimpleKey())
-				m_tokens.push(Token(Token::VALUE, INPUT.mark()));
-			else if(m_flows.top() == FLOW_SEQ)
-				InvalidateSimpleKey();
-		}
+		 // we might have a solo entry in the flow context
+		if(VerifySimpleKey())
+			m_tokens.push(Token(Token::VALUE, INPUT.mark()));
 		
 		m_simpleKeyAllowed = true;
-		m_canBeJSONFlow = false;
 
 		// eat
 		Mark mark = INPUT.mark();
@@ -164,7 +152,6 @@ namespace YAML
 
 		PushIndentTo(INPUT.column(), IndentMarker::SEQ);
 		m_simpleKeyAllowed = true;
-		m_canBeJSONFlow = false;
 
 		// eat
 		Mark mark = INPUT.mark();
@@ -195,9 +182,11 @@ namespace YAML
 	// Value
 	void Scanner::ScanValue()
 	{
+		// just in case we have an empty key
+		InsertPotentialSimpleKey();
+		
 		// and check that simple key
 		bool isSimpleKey = VerifySimpleKey();
-		m_canBeJSONFlow = false;
 		
 		if(isSimpleKey) {
 			// can't follow a simple key with another simple key (dunno why, though - it seems fine)
@@ -230,7 +219,6 @@ namespace YAML
 		// insert a potential simple key
 		InsertPotentialSimpleKey();
 		m_simpleKeyAllowed = false;
-		m_canBeJSONFlow = false;
 
 		// eat the indicator
 		Mark mark = INPUT.mark();
@@ -238,7 +226,7 @@ namespace YAML
 		alias = (indicator == Keys::Alias);
 
 		// now eat the content
-		while(Exp::AlphaNumeric().Matches(INPUT))
+		while(Exp::AlphaNumeric.Matches(INPUT))
 			name += INPUT.get();
 
 		// we need to have read SOMETHING!
@@ -246,7 +234,7 @@ namespace YAML
 			throw ParserException(INPUT.mark(), alias ? ErrorMsg::ALIAS_NOT_FOUND : ErrorMsg::ANCHOR_NOT_FOUND);
 
 		// and needs to end correctly
-		if(INPUT && !Exp::AnchorEnd().Matches(INPUT))
+		if(INPUT && !Exp::AnchorEnd.Matches(INPUT))
 			throw ParserException(INPUT.mark(), alias ? ErrorMsg::CHAR_IN_ALIAS : ErrorMsg::CHAR_IN_ANCHOR);
 
 		// and we're done
@@ -258,40 +246,37 @@ namespace YAML
 	// Tag
 	void Scanner::ScanTag()
 	{
+		std::string handle, suffix;
+
 		// insert a potential simple key
 		InsertPotentialSimpleKey();
 		m_simpleKeyAllowed = false;
-		m_canBeJSONFlow = false;
-
-		Token token(Token::TAG, INPUT.mark());
 
 		// eat the indicator
-		INPUT.get();
-		
-		if(INPUT && INPUT.peek() == Keys::VerbatimTagStart){
-			std::string tag = ScanVerbatimTag(INPUT);
+		Mark mark = INPUT.mark();
+		handle += INPUT.get();
 
-			token.value = tag;
-			token.data = Tag::VERBATIM;
+		// read the handle
+		while(INPUT && INPUT.peek() != Keys::Tag && !Exp::BlankOrBreak.Matches(INPUT))
+			handle += INPUT.get();
+
+		// is there a suffix?
+		if(INPUT.peek() == Keys::Tag) {
+			// eat the indicator
+			handle += INPUT.get();
+
+			// then read it
+			while(INPUT && !Exp::BlankOrBreak.Matches(INPUT))
+				suffix += INPUT.get();
 		} else {
-			bool canBeHandle;
-			token.value = ScanTagHandle(INPUT, canBeHandle);
-			if(!canBeHandle && token.value.empty())
-				token.data = Tag::NON_SPECIFIC;
-			else if(token.value.empty())
-				token.data = Tag::SECONDARY_HANDLE;
-			else
-				token.data = Tag::PRIMARY_HANDLE;
-			
-			// is there a suffix?
-			if(canBeHandle && INPUT.peek() == Keys::Tag) {
-				// eat the indicator
-				INPUT.get();
-				token.params.push_back(ScanTagSuffix(INPUT));
-				token.data = Tag::NAMED_HANDLE;
-			}
+			// this is a bit weird: we keep just the '!' as the handle and move the rest to the suffix
+			suffix = handle.substr(1);
+			handle = "!";
 		}
 
+		Token token(Token::TAG, mark);
+		token.value = handle;
+		token.params.push_back(suffix);
 		m_tokens.push(token);
 	}
 
@@ -302,13 +287,13 @@ namespace YAML
 
 		// set up the scanning parameters
 		ScanScalarParams params;
-		params.end = (InFlowContext() ? Exp::EndScalarInFlow() : Exp::EndScalar()) || (Exp::BlankOrBreak() + Exp::Comment());
+		params.end = (InFlowContext() ? Exp::EndScalarInFlow : Exp::EndScalar) || (Exp::BlankOrBreak + Exp::Comment);
 		params.eatEnd = false;
 		params.indent = (InFlowContext() ? 0 : GetTopIndent() + 1);
-		params.fold = FOLD_FLOW;
+		params.fold = true;
 		params.eatLeadingWhitespace = true;
 		params.trimTrailingSpaces = true;
-		params.chomp = STRIP;
+		params.chomp = CLIP;
 		params.onDocIndicator = BREAK;
 		params.onTabInIndentation = THROW;
 
@@ -320,7 +305,6 @@ namespace YAML
 
 		// can have a simple key only if we ended the scalar by starting a new line
 		m_simpleKeyAllowed = params.leadingSpaces;
-		m_canBeJSONFlow = false;
 
 		// finally, check and see if we ended on an illegal character
 		//if(Exp::IllegalCharInScalar.Matches(INPUT))
@@ -328,7 +312,6 @@ namespace YAML
 
 		Token token(Token::SCALAR, mark);
 		token.value = scalar;
-		token.params.push_back(Token::PLAIN_SCALAR);
 		m_tokens.push(token);
 	}
 
@@ -343,11 +326,11 @@ namespace YAML
 
 		// setup the scanning parameters
 		ScanScalarParams params;
-		params.end = (single ? RegEx(quote) && !Exp::EscSingleQuote() : RegEx(quote));
+		params.end = (single ? RegEx(quote) && !Exp::EscSingleQuote : RegEx(quote));
 		params.eatEnd = true;
 		params.escape = (single ? '\'' : '\\');
 		params.indent = 0;
-		params.fold = FOLD_FLOW;
+		params.fold = true;
 		params.eatLeadingWhitespace = true;
 		params.trimTrailingSpaces = false;
 		params.chomp = CLIP;
@@ -364,7 +347,6 @@ namespace YAML
 		// and scan
 		scalar = ScanScalar(INPUT, params);
 		m_simpleKeyAllowed = false;
-		m_canBeJSONFlow = true;
 
 		Token token(Token::SCALAR, mark);
 		token.value = scalar;
@@ -386,18 +368,17 @@ namespace YAML
 		// eat block indicator ('|' or '>')
 		Mark mark = INPUT.mark();
 		char indicator = INPUT.get();
-		params.fold = (indicator == Keys::FoldedScalar ? FOLD_BLOCK : DONT_FOLD);
+		params.fold = (indicator == Keys::FoldedScalar);
 
 		// eat chomping/indentation indicators
-		params.chomp = CLIP;
-		int n = Exp::Chomp().Match(INPUT);
+		int n = Exp::Chomp.Match(INPUT);
 		for(int i=0;i<n;i++) {
 			char ch = INPUT.get();
 			if(ch == '+')
 				params.chomp = KEEP;
 			else if(ch == '-')
 				params.chomp = STRIP;
-			else if(Exp::Digit().Matches(ch)) {
+			else if(Exp::Digit.Matches(ch)) {
 				if(ch == '0')
 					throw ParserException(INPUT.mark(), ErrorMsg::ZERO_INDENT_IN_BLOCK);
 
@@ -407,16 +388,16 @@ namespace YAML
 		}
 
 		// now eat whitespace
-		while(Exp::Blank().Matches(INPUT))
+		while(Exp::Blank.Matches(INPUT))
 			INPUT.eat(1);
 
 		// and comments to the end of the line
-		if(Exp::Comment().Matches(INPUT))
-			while(INPUT && !Exp::Break().Matches(INPUT))
+		if(Exp::Comment.Matches(INPUT))
+			while(INPUT && !Exp::Break.Matches(INPUT))
 				INPUT.eat(1);
 
 		// if it's not a line break, then we ran into a bad character inline
-		if(INPUT && !Exp::Break().Matches(INPUT))
+		if(INPUT && !Exp::Break.Matches(INPUT))
 			throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_BLOCK);
 
 		// set the initial indentation
@@ -431,7 +412,6 @@ namespace YAML
 
 		// simple keys always ok after block scalars (since we're gonna start a new line anyways)
 		m_simpleKeyAllowed = true;
-		m_canBeJSONFlow = false;
 
 		Token token(Token::SCALAR, mark);
 		token.value = scalar;

src/sequence.cpp

@@ -1,6 +1,9 @@
+#include "crt.h"
 #include "sequence.h"
-#include "eventhandler.h"
 #include "node.h"
+#include "scanner.h"
+#include "token.h"
+#include "emitter.h"
 #include <stdexcept>
 
 namespace YAML
@@ -10,6 +13,12 @@ namespace YAML
 
 	}
 
+	Sequence::Sequence(const std::vector<Node *>& data)
+	{
+		for(std::size_t i=0;i<data.size();i++)
+			m_data.push_back(data[i]->Clone().release());
+	}
+
 	Sequence::~Sequence()
 	{
 		Clear();
@@ -22,6 +31,11 @@ namespace YAML
 		m_data.clear();
 	}
 
+	Content *Sequence::Clone() const
+	{
+		return new Sequence(m_data);
+	}
+
 	bool Sequence::GetBegin(std::vector <Node *>::const_iterator& it) const
 	{
 		it = m_data.begin();
@@ -46,17 +60,84 @@ namespace YAML
 		return m_data.size();
 	}
 
-	void Sequence::Append(std::auto_ptr<Node> pNode)
+	void Sequence::Parse(Scanner *pScanner, const ParserState& state)
 	{
-		m_data.push_back(pNode.release());
+		Clear();
+
+		// split based on start token
+		switch(pScanner->peek().type) {
+			case Token::BLOCK_SEQ_START: ParseBlock(pScanner, state); break;
+			case Token::FLOW_SEQ_START: ParseFlow(pScanner, state); break;
+			default: break;
+		}
 	}
-	
-	void Sequence::EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const
+
+	void Sequence::ParseBlock(Scanner *pScanner, const ParserState& state)
 	{
-		eventHandler.OnSequenceStart(mark, tag, anchor);
+		// eat start token
+		pScanner->pop();
+
+		while(1) {
+			if(pScanner->empty())
+				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ);
+
+			Token token = pScanner->peek();
+			if(token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END)
+				throw ParserException(token.mark, ErrorMsg::END_OF_SEQ);
+
+			pScanner->pop();
+			if(token.type == Token::BLOCK_SEQ_END)
+				break;
+
+			Node *pNode = new Node;
+			m_data.push_back(pNode);
+			
+			// check for null
+			if(!pScanner->empty()) {
+				const Token& token = pScanner->peek();
+				if(token.type == Token::BLOCK_ENTRY || token.type == Token::BLOCK_SEQ_END)
+					continue;
+			}
+			
+			pNode->Parse(pScanner, state);
+		}
+	}
+
+	void Sequence::ParseFlow(Scanner *pScanner, const ParserState& state)
+	{
+		// eat start token
+		pScanner->pop();
+
+		while(1) {
+			if(pScanner->empty())
+				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ_FLOW);
+
+			// first check for end
+			if(pScanner->peek().type == Token::FLOW_SEQ_END) {
+				pScanner->pop();
+				break;
+			}
+
+			// then read the node
+			Node *pNode = new Node;
+			m_data.push_back(pNode);
+			pNode->Parse(pScanner, state);
+
+			// now eat the separator (or could be a sequence end, which we ignore - but if it's neither, then it's a bad node)
+			Token& token = pScanner->peek();
+			if(token.type == Token::FLOW_ENTRY)
+				pScanner->pop();
+			else if(token.type != Token::FLOW_SEQ_END)
+				throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW);
+		}
+	}
+
+	void Sequence::Write(Emitter& out) const
+	{
+		out << BeginSeq;
 		for(std::size_t i=0;i<m_data.size();i++)
-			m_data[i]->EmitEvents(am, eventHandler);
-		eventHandler.OnSequenceEnd();
+			out << *m_data[i];
+		out << EndSeq;
 	}
 
 	int Sequence::Compare(Content *pContent)

src/sequence.h

@@ -15,17 +15,19 @@ namespace YAML
 	{
 	public:
 		Sequence();
+		Sequence(const std::vector<Node *>& data);
 		virtual ~Sequence();
 
 		void Clear();
+		virtual Content *Clone() const;
 
 		virtual bool GetBegin(std::vector <Node *>::const_iterator& it) const;
 		virtual bool GetEnd(std::vector <Node *>::const_iterator& it) const;
 		virtual Node *GetNode(std::size_t i) const;
 		virtual std::size_t GetSize() const;
 
-		virtual void Append(std::auto_ptr<Node> pNode);
-		virtual void EmitEvents(AliasManager& am, EventHandler& eventHandler, const Mark& mark, const std::string& tag, anchor_t anchor) const;
+		virtual void Parse(Scanner *pScanner, const ParserState& state);
+		virtual void Write(Emitter& out) const;
 
 		virtual bool IsSequence() const { return true; }
 
@@ -35,6 +37,10 @@ namespace YAML
 		virtual int Compare(Sequence *pSeq);
 		virtual int Compare(Map *) { return -1; }
 
+	private:
+		void ParseBlock(Scanner *pScanner, const ParserState& state);
+		void ParseFlow(Scanner *pScanner, const ParserState& state);
+
 	protected:
 		std::vector <Node *> m_data;
 	};

src/simplekey.cpp

@@ -1,3 +1,4 @@
+#include "crt.h"
 #include "scanner.h"
 #include "token.h"
 #include "exceptions.h"
@@ -12,11 +13,9 @@ namespace YAML
 
 	void Scanner::SimpleKey::Validate()
 	{
-		// Note: pIndent will *not* be garbage here;
-		//       we "garbage collect" them so we can
-		//       always refer to them
+		// Note: pIndent will *not* be garbage here; see below
 		if(pIndent)
-			pIndent->status = IndentMarker::VALID;
+			pIndent->isValid = true;
 		if(pMapStart)
 			pMapStart->status = Token::VALID;
 		if(pKey)
@@ -25,8 +24,8 @@ namespace YAML
 
 	void Scanner::SimpleKey::Invalidate()
 	{
-		if(pIndent)
-			pIndent->status = IndentMarker::INVALID;
+		// Note: pIndent might be a garbage pointer here, but that's ok
+		//       An indent will only be popped if the simple key is invalid
 		if(pMapStart)
 			pMapStart->status = Token::INVALID;
 		if(pKey)
@@ -38,6 +37,9 @@ namespace YAML
 	{
 		if(!m_simpleKeyAllowed)
 			return false;
+		
+		if(InFlowContext() && m_flows.top() != FLOW_MAP)
+			return false;
 
 		return !ExistsActiveSimpleKey();
 	}
@@ -65,13 +67,11 @@ namespace YAML
 		SimpleKey key(INPUT.mark(), GetFlowLevel());
 
 		// first add a map start, if necessary
-		if(InBlockContext()) {
-			key.pIndent = PushIndentTo(INPUT.column(), IndentMarker::MAP);
-			if(key.pIndent) {
-				key.pIndent->status = IndentMarker::UNKNOWN;
-				key.pMapStart = key.pIndent->pStartToken;
-				key.pMapStart->status = Token::UNVERIFIED;
-			}
+		key.pIndent = PushIndentTo(INPUT.column(), IndentMarker::MAP);
+		if(key.pIndent) {
+			key.pIndent->isValid = false;
+			key.pMapStart = key.pIndent->pStartToken;
+			key.pMapStart->status = Token::UNVERIFIED;
 		}
 
 		// then add the (now unverified) key
@@ -136,4 +136,3 @@ namespace YAML
 			m_simpleKeys.pop();
 	}
 }
-

src/singledocparser.cpp

@@ -1,381 +0,0 @@
-#include "singledocparser.h"
-#include "collectionstack.h"
-#include "directives.h"
-#include "eventhandler.h"
-#include "exceptions.h"
-#include "scanner.h"
-#include "tag.h"
-#include "token.h"
-#include <sstream>
-#include <cstdio>
-#include <algorithm>
-
-namespace YAML
-{
-	SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives): m_scanner(scanner), m_directives(directives), m_pCollectionStack(new CollectionStack), m_curAnchor(0)
-	{
-	}
-
-	SingleDocParser::~SingleDocParser()
-	{
-	}
-
-	// HandleDocument
-	// . Handles the next document
-	// . Throws a ParserException on error.
-	void SingleDocParser::HandleDocument(EventHandler& eventHandler)
-	{
-		assert(!m_scanner.empty()); // guaranteed that there are tokens
-		assert(!m_curAnchor);
-
-		eventHandler.OnDocumentStart(m_scanner.peek().mark);
-		
-		// eat doc start
-		if(m_scanner.peek().type == Token::DOC_START)
-			m_scanner.pop();
-		
-		// recurse!
-		HandleNode(eventHandler);
-		
-		eventHandler.OnDocumentEnd();
-		
-		// and finally eat any doc ends we see
-		while(!m_scanner.empty() && m_scanner.peek().type == Token::DOC_END)
-			m_scanner.pop();
-	}
-	
-	void SingleDocParser::HandleNode(EventHandler& eventHandler)
-	{
-		// an empty node *is* a possibility
-		if(m_scanner.empty()) {
-			eventHandler.OnNull("", NullAnchor);
-			return;
-		}
-		
-		// save location
-		Mark mark = m_scanner.peek().mark;
-		
-		// special case: a value node by itself must be a map, with no header
-		if(m_scanner.peek().type == Token::VALUE) {
-			eventHandler.OnMapStart(mark, "", NullAnchor);
-			HandleMap(eventHandler);
-			eventHandler.OnMapEnd();
-			return;
-		}
-		
-		// special case: an alias node
-		if(m_scanner.peek().type == Token::ALIAS) {
-			eventHandler.OnAlias(mark, LookupAnchor(mark, m_scanner.peek().value));
-			m_scanner.pop();
-			return;
-		}
-		
-		std::string tag;
-		anchor_t anchor;
-		ParseProperties(tag, anchor);
-		
-		if (tag.empty()) {
-			const Token& token = m_scanner.peek();
-			const std::vector<std::string>& tparams = token.params;
-			if (token.type != Token::SCALAR ||
-					std::find(tparams.begin(), tparams.end(), Token::PLAIN_SCALAR) != tparams.end()) {
-				tag = "?";
-			} else {
-				tag = "!";
-			}
-		}
-		
-		// now split based on what kind of node we should be
-		switch(m_scanner.peek().type) {
-			case Token::SCALAR:
-				eventHandler.OnScalar(mark, tag, anchor, m_scanner.peek().value);
-				m_scanner.pop();
-				return;
-			case Token::FLOW_SEQ_START:
-			case Token::BLOCK_SEQ_START:
-				eventHandler.OnSequenceStart(mark, tag, anchor);
-				HandleSequence(eventHandler);
-				eventHandler.OnSequenceEnd();
-				return;
-			case Token::FLOW_MAP_START:
-			case Token::BLOCK_MAP_START:
-				eventHandler.OnMapStart(mark, tag, anchor);
-				HandleMap(eventHandler);
-				eventHandler.OnMapEnd();
-				return;
-			case Token::KEY:
-				// compact maps can only go in a flow sequence
-				if(m_pCollectionStack->GetCurCollectionType() == CollectionType::FlowSeq) {
-					eventHandler.OnMapStart(mark, tag, anchor);
-					HandleMap(eventHandler);
-					eventHandler.OnMapEnd();
-					return;
-				}
-				break;
-			default:
-				break;
-		}
-		
-		eventHandler.OnNull(tag, anchor);
-	}
-	
-	void SingleDocParser::HandleSequence(EventHandler& eventHandler)
-	{
-		// split based on start token
-		switch(m_scanner.peek().type) {
-			case Token::BLOCK_SEQ_START: HandleBlockSequence(eventHandler); break;
-			case Token::FLOW_SEQ_START: HandleFlowSequence(eventHandler); break;
-			default: break;
-		}
-	}
-	
-	void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler)
-	{
-		// eat start token
-		m_scanner.pop();
-		m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq);
-		
-		while(1) {
-			if(m_scanner.empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ);
-			
-			Token token = m_scanner.peek();
-			if(token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END)
-				throw ParserException(token.mark, ErrorMsg::END_OF_SEQ);
-			
-			m_scanner.pop();
-			if(token.type == Token::BLOCK_SEQ_END)
-				break;
-			
-			// check for null
-			if(!m_scanner.empty()) {
-				const Token& token = m_scanner.peek();
-				if(token.type == Token::BLOCK_ENTRY || token.type == Token::BLOCK_SEQ_END) {
-					eventHandler.OnNull("", NullAnchor);
-					continue;
-				}
-			}
-			
-			HandleNode(eventHandler);
-		}
-		
-		m_pCollectionStack->PopCollectionType(CollectionType::BlockSeq);
-	}
-	
-	void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler)
-	{
-		// eat start token
-		m_scanner.pop();
-		m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq);
-		
-		while(1) {
-			if(m_scanner.empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ_FLOW);
-			
-			// first check for end
-			if(m_scanner.peek().type == Token::FLOW_SEQ_END) {
-				m_scanner.pop();
-				break;
-			}
-			
-			// then read the node
-			HandleNode(eventHandler);
-			
-			// now eat the separator (or could be a sequence end, which we ignore - but if it's neither, then it's a bad node)
-			Token& token = m_scanner.peek();
-			if(token.type == Token::FLOW_ENTRY)
-				m_scanner.pop();
-			else if(token.type != Token::FLOW_SEQ_END)
-				throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW);
-		}
-		
-		m_pCollectionStack->PopCollectionType(CollectionType::FlowSeq);
-	}
-	
-	void SingleDocParser::HandleMap(EventHandler& eventHandler)
-	{
-		// split based on start token
-		switch(m_scanner.peek().type) {
-			case Token::BLOCK_MAP_START: HandleBlockMap(eventHandler); break;
-			case Token::FLOW_MAP_START: HandleFlowMap(eventHandler); break;
-			case Token::KEY: HandleCompactMap(eventHandler); break;
-			case Token::VALUE: HandleCompactMapWithNoKey(eventHandler); break;
-			default: break;
-		}
-	}
-	
-	void SingleDocParser::HandleBlockMap(EventHandler& eventHandler)
-	{
-		// eat start token
-		m_scanner.pop();
-		m_pCollectionStack->PushCollectionType(CollectionType::BlockMap);
-		
-		while(1) {
-			if(m_scanner.empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP);
-			
-			Token token = m_scanner.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) {
-				m_scanner.pop();
-				break;
-			}
-			
-			// grab key (if non-null)
-			if(token.type == Token::KEY) {
-				m_scanner.pop();
-				HandleNode(eventHandler);
-			} else {
-				eventHandler.OnNull("", NullAnchor);
-			}
-			
-			// now grab value (optional)
-			if(!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
-				m_scanner.pop();
-				HandleNode(eventHandler);
-			} else {
-				eventHandler.OnNull("", NullAnchor);
-			}
-		}
-		
-		m_pCollectionStack->PopCollectionType(CollectionType::BlockMap);
-	}
-	
-	void SingleDocParser::HandleFlowMap(EventHandler& eventHandler)
-	{
-		// eat start token
-		m_scanner.pop();
-		m_pCollectionStack->PushCollectionType(CollectionType::FlowMap);
-		
-		while(1) {
-			if(m_scanner.empty())
-				throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP_FLOW);
-			
-			Token& token = m_scanner.peek();
-			// first check for end
-			if(token.type == Token::FLOW_MAP_END) {
-				m_scanner.pop();
-				break;
-			}
-			
-			// grab key (if non-null)
-			if(token.type == Token::KEY) {
-				m_scanner.pop();
-				HandleNode(eventHandler);
-			} else {
-				eventHandler.OnNull("", NullAnchor);
-			}
-			
-			// now grab value (optional)
-			if(!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
-				m_scanner.pop();
-				HandleNode(eventHandler);
-			} else {
-				eventHandler.OnNull("", NullAnchor);
-			}
-			
-			// now eat the separator (or could be a map end, which we ignore - but if it's neither, then it's a bad node)
-			Token& nextToken = m_scanner.peek();
-			if(nextToken.type == Token::FLOW_ENTRY)
-				m_scanner.pop();
-			else if(nextToken.type != Token::FLOW_MAP_END)
-				throw ParserException(nextToken.mark, ErrorMsg::END_OF_MAP_FLOW);
-		}
-		
-		m_pCollectionStack->PopCollectionType(CollectionType::FlowMap);
-	}
-	
-	// . Single "key: value" pair in a flow sequence
-	void SingleDocParser::HandleCompactMap(EventHandler& eventHandler)
-	{
-		m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
-		
-		// grab key
-		m_scanner.pop();
-		HandleNode(eventHandler);
-		
-		// now grab value (optional)
-		if(!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
-			m_scanner.pop();
-			HandleNode(eventHandler);
-		} else {
-			eventHandler.OnNull("", NullAnchor);
-		}
-		
-		m_pCollectionStack->PopCollectionType(CollectionType::CompactMap);
-	}
-	
-	// . Single ": value" pair in a flow sequence
-	void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler)
-	{
-		m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
-		
-		// null key
-		eventHandler.OnNull("", NullAnchor);
-		
-		// grab value
-		m_scanner.pop();
-		HandleNode(eventHandler);
-		
-		m_pCollectionStack->PopCollectionType(CollectionType::CompactMap);
-	}
-	
-	// ParseProperties
-	// . Grabs any tag or anchor tokens and deals with them.
-	void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor)
-	{
-		tag.clear();
-		anchor = NullAnchor;
-		
-		while(1) {
-			if(m_scanner.empty())
-				return;
-			
-			switch(m_scanner.peek().type) {
-				case Token::TAG: ParseTag(tag); break;
-				case Token::ANCHOR: ParseAnchor(anchor); break;
-				default: return;
-			}
-		}
-	}
-	
-	void SingleDocParser::ParseTag(std::string& tag)
-	{
-		Token& token = m_scanner.peek();
-		if(!tag.empty())
-			throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS);
-		
-		Tag tagInfo(token);
-		tag = tagInfo.Translate(m_directives);
-		m_scanner.pop();
-	}
-	
-	void SingleDocParser::ParseAnchor(anchor_t& anchor)
-	{
-		Token& token = m_scanner.peek();
-		if(anchor)
-			throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS);
-		
-		anchor = RegisterAnchor(token.value);
-		m_scanner.pop();
-	}
-	
-	anchor_t SingleDocParser::RegisterAnchor(const std::string& name)
-	{
-		if(name.empty())
-			return NullAnchor;
-		
-		return m_anchors[name] = ++m_curAnchor;
-	}
-	
-	anchor_t SingleDocParser::LookupAnchor(const Mark& mark, const std::string& name) const
-	{
-		Anchors::const_iterator it = m_anchors.find(name);
-		if(it == m_anchors.end())
-			throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR);
-		
-		return it->second;
-	}
-}

src/singledocparser.h

@@ -1,63 +0,0 @@
-#pragma once
-
-#ifndef SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-
-#include "anchor.h"
-#include "noncopyable.h"
-#include <string>
-#include <map>
-#include <memory>
-
-namespace YAML
-{
-	struct Directives;
-	struct Mark;
-	struct Token;
-	class CollectionStack;
-	class EventHandler;
-	class Node;
-	class Scanner;
-	
-	class SingleDocParser: private noncopyable
-	{
-	public:
-		SingleDocParser(Scanner& scanner, const Directives& directives);
-		~SingleDocParser();
-
-		void HandleDocument(EventHandler& eventHandler);
-
-	private:
-		void HandleNode(EventHandler& eventHandler);
-		
-		void HandleSequence(EventHandler& eventHandler);
-		void HandleBlockSequence(EventHandler& eventHandler);
-		void HandleFlowSequence(EventHandler& eventHandler);
-		
-		void HandleMap(EventHandler& eventHandler);
-		void HandleBlockMap(EventHandler& eventHandler);
-		void HandleFlowMap(EventHandler& eventHandler);
-		void HandleCompactMap(EventHandler& eventHandler);
-		void HandleCompactMapWithNoKey(EventHandler& eventHandler);
-		
-		void ParseProperties(std::string& tag, anchor_t& anchor);
-		void ParseTag(std::string& tag);
-		void ParseAnchor(anchor_t& anchor);
-		
-		anchor_t RegisterAnchor(const std::string& name);
-		anchor_t LookupAnchor(const Mark& mark, const std::string& name) const;
-		
-	private:
-		Scanner& m_scanner;
-		const Directives& m_directives;
-		std::auto_ptr<CollectionStack> m_pCollectionStack;
-		
-		typedef std::map<std::string, anchor_t> Anchors;
-		Anchors m_anchors;
-		
-		anchor_t m_curAnchor;
-	};
-}
-
-#endif // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/stream.cpp

@@ -1,3 +1,4 @@
+#include "crt.h"
 #include "stream.h"
 #include <iostream>
 #include "exp.h"

src/stringsource.h

@@ -30,11 +30,6 @@ namespace YAML
 			++m_offset;
 			return *this;
 		}
-		
-		StringCharSource& operator += (std::size_t offset) {
-			m_offset += offset;
-			return *this;
-		}
 	private:
 		const char *m_str;
 		std::size_t m_size;

src/tag.cpp

@@ -1,50 +0,0 @@
-#include "tag.h"
-#include "directives.h"
-#include "token.h"
-#include <cassert>
-
-namespace YAML
-{
-	Tag::Tag(const Token& token): type(static_cast<TYPE>(token.data))
-	{
-		switch(type) {
-			case VERBATIM:
-				value = token.value;
-				break;
-			case PRIMARY_HANDLE:
-				value = token.value;
-				break;
-			case SECONDARY_HANDLE:
-				value = token.value;
-				break;
-			case NAMED_HANDLE:
-				handle = token.value;
-				value = token.params[0];
-				break;
-			case NON_SPECIFIC:
-				break;
-			default:
-				assert(false);
-		}
-	}
-
-	const std::string Tag::Translate(const Directives& directives)
-	{
-		switch(type) {
-			case VERBATIM:
-				return value;
-			case PRIMARY_HANDLE:
-				return directives.TranslateTagHandle("!") + value;
-			case SECONDARY_HANDLE:
-				return directives.TranslateTagHandle("!!") + value;
-			case NAMED_HANDLE:
-				return directives.TranslateTagHandle("!" + handle + "!") + value;
-			case NON_SPECIFIC:
-				// TODO:
-				return "!";
-			default:
-				assert(false);
-		}
-	}
-}
-

src/tag.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#ifndef TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include <string>
-
-namespace YAML
-{
-	struct Token;
-	struct Directives;
-
-	struct Tag {
-		enum TYPE {
-			VERBATIM, PRIMARY_HANDLE, SECONDARY_HANDLE, NAMED_HANDLE, NON_SPECIFIC
-		};
-		
-		Tag(const Token& token);
-		const std::string Translate(const Directives& directives);
-		
-		TYPE type;
-		std::string handle, value;
-	};
-}
-
-#endif // TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/token.cpp

@@ -1,6 +0,0 @@
-#include "token.h"
-
-namespace YAML
-{
-  const std::string Token::PLAIN_SCALAR("pln");
-}

src/token.h

@@ -5,7 +5,7 @@
 
 
 #include "mark.h"
-#include <iostream>
+#include <ios>
 #include <string>
 #include <vector>
 
@@ -24,7 +24,6 @@ namespace YAML
 		"FLOW_MAP_START",
 		"FLOW_SEQ_END",
 		"FLOW_MAP_END",
-		"FLOW_MAP_COMPACT",
 		"FLOW_ENTRY",
 		"KEY",
 		"VALUE",
@@ -50,7 +49,6 @@ namespace YAML
 			FLOW_MAP_START,
 			FLOW_SEQ_END,
 			FLOW_MAP_END,
-			FLOW_MAP_COMPACT,
 			FLOW_ENTRY,
 			KEY,
 			VALUE,
@@ -59,11 +57,9 @@ namespace YAML
 			TAG,
 			SCALAR
 		};
-		
-		static const std::string PLAIN_SCALAR;
 				
 		// data
-		Token(TYPE type_, const Mark& mark_): status(VALID), type(type_), mark(mark_), data(0) {}
+		Token(TYPE type_, const Mark& mark_): status(VALID), type(type_), mark(mark_) {}
 
 		friend std::ostream& operator << (std::ostream& out, const Token& token) {
 			out << TokenNames[token.type] << std::string(": ") << token.value;
@@ -77,7 +73,6 @@ namespace YAML
 		Mark mark;
 		std::string value;
 		std::vector <std::string> params;
-		int data;
 	};
 }
 

test.vcproj

@@ -1,226 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="test"
-	ProjectGUID="{D1108F40-6ADF-467E-A95A-236C39A515C5}"
-	RootNamespace="test"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			CharacterSet="2"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				AdditionalOptions="/D_SCL_SECURE_NO_WARNINGS"
-				Optimization="0"
-				AdditionalIncludeDirectories="include"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				WarningLevel="3"
-				DebugInformationFormat="4"
-				DisableSpecificWarnings="4127;4355"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="yamlcppd.lib"
-				AdditionalLibraryDirectories="lib"
-				GenerateDebugInformation="true"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			CharacterSet="2"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				AdditionalOptions="/D_SCL_SECURE_NO_WARNINGS"
-				Optimization="2"
-				EnableIntrinsicFunctions="true"
-				AdditionalIncludeDirectories="include"
-				RuntimeLibrary="2"
-				EnableFunctionLevelLinking="true"
-				WarningLevel="3"
-				DebugInformationFormat="3"
-				DisableSpecificWarnings="4127;4355"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="yamlcpp.lib"
-				AdditionalLibraryDirectories="lib"
-				GenerateDebugInformation="true"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath=".\test\emittertests.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\test\main.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\test\parsertests.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\test\spectests.cpp"
-				>
-			</File>
-			<File
-				RelativePath=".\test\tests.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-			<File
-				RelativePath=".\test\emittertests.h"
-				>
-			</File>
-			<File
-				RelativePath=".\test\parsertests.h"
-				>
-			</File>
-			<File
-				RelativePath=".\test\spectests.h"
-				>
-			</File>
-			<File
-				RelativePath=".\test\tests.h"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

test/CMakeLists.txt

@@ -1,10 +0,0 @@
-file(GLOB test_headers [a-z]*.h)
-file(GLOB test_sources [a-z]*.cpp)
-
-add_executable(run-tests
-	${test_sources}
-	${test_headers}
-)
-target_link_libraries(run-tests yaml-cpp)
-
-add_test(yaml-reader-test run-tests)

test/emittertests.cpp

@@ -1,851 +0,0 @@
-#include "tests.h"
-#include "yaml.h"
-
-namespace Test
-{
-	namespace Emitter {
-		////////////////////////////////////////////////////////////////////////////////////////////////////////
-		// correct emitting
-
-		void SimpleScalar(YAML::Emitter& out, std::string& desiredOutput) {
-			out << "Hello, World!";
-			desiredOutput = "--- Hello, World!";
-		}
-		
-		void SimpleSeq(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::BeginSeq;
-			out << "eggs";
-			out << "bread";
-			out << "milk";
-			out << YAML::EndSeq;
-
-			desiredOutput = "---\n- eggs\n- bread\n- milk";
-		}
-		
-		void SimpleFlowSeq(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::Flow;
-			out << YAML::BeginSeq;
-			out << "Larry";
-			out << "Curly";
-			out << "Moe";
-			out << YAML::EndSeq;
-			
-			desiredOutput = "--- [Larry, Curly, Moe]";
-		}
-		
-		void EmptyFlowSeq(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::Flow;
-			out << YAML::BeginSeq;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "--- []";
-		}
-		
-		void NestedBlockSeq(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::BeginSeq;
-			out << "item 1";
-			out << YAML::BeginSeq << "subitem 1" << "subitem 2" << YAML::EndSeq;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- item 1\n-\n  - subitem 1\n  - subitem 2";
-		}
-		
-		void NestedFlowSeq(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::BeginSeq;
-			out << "one";
-			out << YAML::Flow << YAML::BeginSeq << "two" << "three" << YAML::EndSeq;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- one\n- [two, three]";
-		}
-
-		void SimpleMap(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::BeginMap;
-			out << YAML::Key << "name";
-			out << YAML::Value << "Ryan Braun";
-			out << YAML::Key << "position";
-			out << YAML::Value << "3B";
-			out << YAML::EndMap;
-
-			desiredOutput = "---\nname: Ryan Braun\nposition: 3B";
-		}
-		
-		void SimpleFlowMap(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::Flow;
-			out << YAML::BeginMap;
-			out << YAML::Key << "shape";
-			out << YAML::Value << "square";
-			out << YAML::Key << "color";
-			out << YAML::Value << "blue";
-			out << YAML::EndMap;
-			
-			desiredOutput = "--- {shape: square, color: blue}";
-		}
-		
-		void MapAndList(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::BeginMap;
-			out << YAML::Key << "name";
-			out << YAML::Value << "Barack Obama";
-			out << YAML::Key << "children";
-			out << YAML::Value << YAML::BeginSeq << "Sasha" << "Malia" << YAML::EndSeq;
-			out << YAML::EndMap;
-
-			desiredOutput = "---\nname: Barack Obama\nchildren:\n  - Sasha\n  - Malia";
-		}
-		
-		void ListAndMap(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::BeginSeq;
-			out << "item 1";
-			out << YAML::BeginMap;
-			out << YAML::Key << "pens" << YAML::Value << 8;
-			out << YAML::Key << "pencils" << YAML::Value << 14;
-			out << YAML::EndMap;
-			out << "item 2";
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- item 1\n-\n  pens: 8\n  pencils: 14\n- item 2";
-		}
-
-		void NestedBlockMap(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::BeginMap;
-			out << YAML::Key << "name";
-			out << YAML::Value << "Fred";
-			out << YAML::Key << "grades";
-			out << YAML::Value;
-			out << YAML::BeginMap;
-			out << YAML::Key << "algebra" << YAML::Value << "A";
-			out << YAML::Key << "physics" << YAML::Value << "C+";
-			out << YAML::Key << "literature" << YAML::Value << "B";
-			out << YAML::EndMap;
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\nname: Fred\ngrades:\n  algebra: A\n  physics: C+\n  literature: B";
-		}
-
-		void NestedFlowMap(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::Flow;
-			out << YAML::BeginMap;
-			out << YAML::Key << "name";
-			out << YAML::Value << "Fred";
-			out << YAML::Key << "grades";
-			out << YAML::Value;
-			out << YAML::BeginMap;
-			out << YAML::Key << "algebra" << YAML::Value << "A";
-			out << YAML::Key << "physics" << YAML::Value << "C+";
-			out << YAML::Key << "literature" << YAML::Value << "B";
-			out << YAML::EndMap;
-			out << YAML::EndMap;
-			
-			desiredOutput = "--- {name: Fred, grades: {algebra: A, physics: C+, literature: B}}";
-		}
-		
-		void MapListMix(YAML::Emitter& out, std::string& desiredOutput) {
-			out << YAML::BeginMap;
-			out << YAML::Key << "name";
-			out << YAML::Value << "Bob";
-			out << YAML::Key << "position";
-			out << YAML::Value;
-			out << YAML::Flow << YAML::BeginSeq << 2 << 4 << YAML::EndSeq;
-			out << YAML::Key << "invincible" << YAML::Value << YAML::OnOffBool << false;
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\nname: Bob\nposition: [2, 4]\ninvincible: off";
-		}
-
-		void SimpleLongKey(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::LongKey;
-			out << YAML::BeginMap;
-			out << YAML::Key << "height";
-			out << YAML::Value << "5'9\"";
-			out << YAML::Key << "weight";
-			out << YAML::Value << 145;
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\n? height\n: 5'9\"\n? weight\n: 145";
-		}
-		
-		void SingleLongKey(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginMap;
-			out << YAML::Key << "age";
-			out << YAML::Value << "24";
-			out << YAML::LongKey << YAML::Key << "height";
-			out << YAML::Value << "5'9\"";
-			out << YAML::Key << "weight";
-			out << YAML::Value << 145;
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\nage: 24\n? height\n: 5'9\"\nweight: 145";
-		}
-		
-		void ComplexLongKey(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::LongKey;
-			out << YAML::BeginMap;
-			out << YAML::Key << YAML::BeginSeq << 1 << 3 << YAML::EndSeq;
-			out << YAML::Value << "monster";
-			out << YAML::Key << YAML::Flow << YAML::BeginSeq << 2 << 0 << YAML::EndSeq;
-			out << YAML::Value << "demon";
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\n?\n  - 1\n  - 3\n: monster\n? [2, 0]\n: demon";
-		}
-
-		void AutoLongKey(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginMap;
-			out << YAML::Key << YAML::BeginSeq << 1 << 3 << YAML::EndSeq;
-			out << YAML::Value << "monster";
-			out << YAML::Key << YAML::Flow << YAML::BeginSeq << 2 << 0 << YAML::EndSeq;
-			out << YAML::Value << "demon";
-			out << YAML::Key << "the origin";
-			out << YAML::Value << "angel";
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\n?\n  - 1\n  - 3\n: monster\n? [2, 0]\n: demon\nthe origin: angel";
-		}
-		
-		void ScalarFormat(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << "simple scalar";
-			out << YAML::SingleQuoted << "explicit single-quoted scalar";
-			out << YAML::DoubleQuoted << "explicit double-quoted scalar";
-			out << "auto-detected\ndouble-quoted scalar";
-			out << "a non-\"auto-detected\" double-quoted scalar";
-			out << YAML::Literal << "literal scalar\nthat may span\nmany, many\nlines and have \"whatever\" crazy\tsymbols that we like";
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- simple scalar\n- 'explicit single-quoted scalar'\n- \"explicit double-quoted scalar\"\n- \"auto-detected\\x0adouble-quoted scalar\"\n- a non-\"auto-detected\" double-quoted scalar\n- |\n  literal scalar\n  that may span\n  many, many\n  lines and have \"whatever\" crazy\tsymbols that we like";
-		}
-
-		void AutoLongKeyScalar(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginMap;
-			out << YAML::Key << YAML::Literal << "multi-line\nscalar";
-			out << YAML::Value << "and its value";
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\n? |\n  multi-line\n  scalar\n: and its value";
-		}
-		
-		void LongKeyFlowMap(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::Flow;
-			out << YAML::BeginMap;
-			out << YAML::Key << "simple key";
-			out << YAML::Value << "and value";
-			out << YAML::LongKey << YAML::Key << "long key";
-			out << YAML::Value << "and its value";
-			out << YAML::EndMap;
-			
-			desiredOutput = "--- {simple key: and value, ? long key: and its value}";
-		}
-
-		void BlockMapAsKey(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginMap;
-			out << YAML::Key;
-			out << YAML::BeginMap;
-			out << YAML::Key << "key" << YAML::Value << "value";
-			out << YAML::Key << "next key" << YAML::Value << "next value";
-			out << YAML::EndMap;
-			out << YAML::Value;
-			out << "total value";
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\n?\n  key: value\n  next key: next value\n: total value";
-		}
-		
-		void AliasAndAnchor(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << YAML::Anchor("fred");
-			out << YAML::BeginMap;
-			out << YAML::Key << "name" << YAML::Value << "Fred";
-			out << YAML::Key << "age" << YAML::Value << 42;
-			out << YAML::EndMap;
-			out << YAML::Alias("fred");
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- &fred\n  name: Fred\n  age: 42\n- *fred";
-		}
-
-		void AliasAndAnchorWithNull(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << YAML::Anchor("fred") << YAML::Null;
-			out << YAML::Alias("fred");
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- &fred ~\n- *fred";
-		}
-		
-		void SimpleVerbatimTag(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::VerbatimTag("!foo") << "bar";
-			
-			desiredOutput = "--- !<!foo> bar";
-		}
-
-		void VerbatimTagInBlockSeq(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << YAML::VerbatimTag("!foo") << "bar";
-			out << "baz";
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- !<!foo> bar\n- baz";
-		}
-
-		void VerbatimTagInFlowSeq(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::Flow << YAML::BeginSeq;
-			out << YAML::VerbatimTag("!foo") << "bar";
-			out << "baz";
-			out << YAML::EndSeq;
-			
-			desiredOutput = "--- [!<!foo> bar, baz]";
-		}
-
-		void VerbatimTagInFlowSeqWithNull(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::Flow << YAML::BeginSeq;
-			out << YAML::VerbatimTag("!foo") << YAML::Null;
-			out << "baz";
-			out << YAML::EndSeq;
-			
-			desiredOutput = "--- [!<!foo> ~, baz]";
-		}
-
-		void VerbatimTagInBlockMap(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginMap;
-			out << YAML::Key << YAML::VerbatimTag("!foo") << "bar";
-			out << YAML::Value << YAML::VerbatimTag("!waz") << "baz";
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\n!<!foo> bar: !<!waz> baz";
-		}
-
-		void VerbatimTagInFlowMap(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::Flow << YAML::BeginMap;
-			out << YAML::Key << YAML::VerbatimTag("!foo") << "bar";
-			out << YAML::Value << "baz";
-			out << YAML::EndMap;
-			
-			desiredOutput = "--- {!<!foo> bar: baz}";
-		}
-
-		void VerbatimTagInFlowMapWithNull(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::Flow << YAML::BeginMap;
-			out << YAML::Key << YAML::VerbatimTag("!foo") << YAML::Null;
-			out << YAML::Value << "baz";
-			out << YAML::EndMap;
-			
-			desiredOutput = "--- {!<!foo> ~: baz}";
-		}
-		
-		void VerbatimTagWithEmptySeq(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::VerbatimTag("!foo") << YAML::BeginSeq << YAML::EndSeq;
-			
-			desiredOutput = "--- !<!foo>\n[]";
-		}
-
-		void VerbatimTagWithEmptyMap(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::VerbatimTag("!bar") << YAML::BeginMap << YAML::EndMap;
-			
-			desiredOutput = "--- !<!bar>\n{}";
-		}
-
-		void VerbatimTagWithEmptySeqAndMap(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << YAML::VerbatimTag("!foo") << YAML::BeginSeq << YAML::EndSeq;
-			out << YAML::VerbatimTag("!bar") << YAML::BeginMap << YAML::EndMap;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- !<!foo>\n  []\n- !<!bar>\n  {}";
-		}
-
-		void ByKindTagWithScalar(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << YAML::DoubleQuoted << "12";
-			out << "12";
-			out << YAML::TagByKind << "12";
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- \"12\"\n- 12\n- ! 12";
-		}
-
-		void LocalTagWithScalar(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::LocalTag("foo") << "bar";
-			
-			desiredOutput = "--- !foo bar";
-		}
-
-		void BadLocalTag(YAML::Emitter& out, std::string& desiredError)
-		{
-			out << YAML::LocalTag("e!far") << "bar";
-			
-			desiredError = "invalid tag";
-		}
-
-		void ComplexDoc(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginMap;
-			out << YAML::Key << "receipt";
-			out << YAML::Value << "Oz-Ware Purchase Invoice";
-			out << YAML::Key << "date";
-			out << YAML::Value << "2007-08-06";
-			out << YAML::Key << "customer";
-			out << YAML::Value;
-			out << YAML::BeginMap;
-			out << YAML::Key << "given";
-			out << YAML::Value << "Dorothy";
-			out << YAML::Key << "family";
-			out << YAML::Value << "Gale";
-			out << YAML::EndMap;
-			out << YAML::Key << "items";
-			out << YAML::Value;
-			out << YAML::BeginSeq;
-			out << YAML::BeginMap;
-			out << YAML::Key << "part_no";
-			out << YAML::Value << "A4786";
-			out << YAML::Key << "descrip";
-			out << YAML::Value << "Water Bucket (Filled)";
-			out << YAML::Key << "price";
-			out << YAML::Value << 1.47;
-			out << YAML::Key << "quantity";
-			out << YAML::Value << 4;
-			out << YAML::EndMap;
-			out << YAML::BeginMap;
-			out << YAML::Key << "part_no";
-			out << YAML::Value << "E1628";
-			out << YAML::Key << "descrip";
-			out << YAML::Value << "High Heeled \"Ruby\" Slippers";
-			out << YAML::Key << "price";
-			out << YAML::Value << 100.27;
-			out << YAML::Key << "quantity";
-			out << YAML::Value << 1;
-			out << YAML::EndMap;
-			out << YAML::EndSeq;
-			out << YAML::Key << "bill-to";
-			out << YAML::Value << YAML::Anchor("id001");
-			out << YAML::BeginMap;
-			out << YAML::Key << "street";
-			out << YAML::Value << YAML::Literal << "123 Tornado Alley\nSuite 16";
-			out << YAML::Key << "city";
-			out << YAML::Value << "East Westville";
-			out << YAML::Key << "state";
-			out << YAML::Value << "KS";
-			out << YAML::EndMap;
-			out << YAML::Key << "ship-to";
-			out << YAML::Value << YAML::Alias("id001");
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\nreceipt: Oz-Ware Purchase Invoice\ndate: 2007-08-06\ncustomer:\n  given: Dorothy\n  family: Gale\nitems:\n  -\n    part_no: A4786\n    descrip: Water Bucket (Filled)\n    price: 1.47\n    quantity: 4\n  -\n    part_no: E1628\n    descrip: High Heeled \"Ruby\" Slippers\n    price: 100.27\n    quantity: 1\nbill-to: &id001\n  street: |\n    123 Tornado Alley\n    Suite 16\n  city: East Westville\n  state: KS\nship-to: *id001";
-		}
-
-		void STLContainers(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			std::vector <int> primes;
-			primes.push_back(2);
-			primes.push_back(3);
-			primes.push_back(5);
-			primes.push_back(7);
-			primes.push_back(11);
-			primes.push_back(13);
-			out << YAML::Flow << primes;
-			std::map <std::string, int> ages;
-			ages["Daniel"] = 26;
-			ages["Jesse"] = 24;
-			out << ages;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- [2, 3, 5, 7, 11, 13]\n-\n  Daniel: 26\n  Jesse: 24";
-		}
-
-		void SimpleComment(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginMap;
-			out << YAML::Key << "method";
-			out << YAML::Value << "least squares" << YAML::Comment("should we change this method?");
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\nmethod: least squares  # should we change this method?";
-		}
-
-		void MultiLineComment(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << "item 1" << YAML::Comment("really really long\ncomment that couldn't possibly\nfit on one line");
-			out << "item 2";
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- item 1  # really really long\n          # comment that couldn't possibly\n          # fit on one line\n- item 2";
-		}
-
-		void ComplexComments(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginMap;
-			out << YAML::LongKey << YAML::Key << "long key" << YAML::Comment("long key");
-			out << YAML::Value << "value";
-			out << YAML::EndMap;
-			
-			desiredOutput = "---\n? long key  # long key\n: value";
-		}
-
-		void Indentation(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::Indent(4);
-			out << YAML::BeginSeq;
-			out << YAML::BeginMap;
-			out << YAML::Key << "key 1" << YAML::Value << "value 1";
-			out << YAML::Key << "key 2" << YAML::Value << YAML::BeginSeq << "a" << "b" << "c" << YAML::EndSeq;
-			out << YAML::EndMap;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n-\n    key 1: value 1\n    key 2:\n        - a\n        - b\n        - c";
-		}
-
-		void SimpleGlobalSettings(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out.SetIndent(4);
-			out.SetMapFormat(YAML::LongKey);
-
-			out << YAML::BeginSeq;
-			out << YAML::BeginMap;
-			out << YAML::Key << "key 1" << YAML::Value << "value 1";
-			out << YAML::Key << "key 2" << YAML::Value << YAML::Flow << YAML::BeginSeq << "a" << "b" << "c" << YAML::EndSeq;
-			out << YAML::EndMap;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n-\n    ? key 1\n    : value 1\n    ? key 2\n    : [a, b, c]";
-		}
-		
-		void ComplexGlobalSettings(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << YAML::Block;
-			out << YAML::BeginMap;
-			out << YAML::Key << "key 1" << YAML::Value << "value 1";
-			out << YAML::Key << "key 2" << YAML::Value;
-			out.SetSeqFormat(YAML::Flow);
-			out << YAML::BeginSeq << "a" << "b" << "c" << YAML::EndSeq;
-			out << YAML::EndMap;
-			out << YAML::BeginMap;
-			out << YAML::Key << YAML::BeginSeq << 1 << 2 << YAML::EndSeq;
-			out << YAML::Value << YAML::BeginMap << YAML::Key << "a" << YAML::Value << "b" << YAML::EndMap;
-			out << YAML::EndMap;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n-\n  key 1: value 1\n  key 2: [a, b, c]\n-\n  ? [1, 2]\n  :\n    a: b";
-		}
-
-		void Null(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << YAML::Null;
-			out << YAML::BeginMap;
-			out << YAML::Key << "null value" << YAML::Value << YAML::Null;
-			out << YAML::Key << YAML::Null << YAML::Value << "null key";
-			out << YAML::EndMap;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- ~\n-\n  null value: ~\n  ~: null key";
-		}
-		
-		void EscapedUnicode(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::EscapeNonAscii << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
-			
-			desiredOutput = "--- \"$ \\xa2 \\u20ac \\U00024b62\"";
-		}
-		
-		void Unicode(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
-			desiredOutput = "--- \x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
-		}
-		
-		void DoubleQuotedUnicode(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::DoubleQuoted << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
-			desiredOutput = "--- \"\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2\"";
-		}
-		
-		struct Foo {
-			Foo(): x(0) {}
-			Foo(int x_, const std::string& bar_): x(x_), bar(bar_) {}
-			
-			int x;
-			std::string bar;
-		};
-		
-		YAML::Emitter& operator << (YAML::Emitter& out, const Foo& foo) {
-			out << YAML::BeginMap;
-			out << YAML::Key << "x" << YAML::Value << foo.x;
-			out << YAML::Key << "bar" << YAML::Value << foo.bar;
-			out << YAML::EndMap;
-			return out;
-		}
-		
-		void UserType(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			out << YAML::BeginSeq;
-			out << Foo(5, "hello");
-			out << Foo(3, "goodbye");
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n-\n  x: 5\n  bar: hello\n-\n  x: 3\n  bar: goodbye";
-		}
-		
-		void UserTypeInContainer(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			std::vector<Foo> fv;
-			fv.push_back(Foo(5, "hello"));
-			fv.push_back(Foo(3, "goodbye"));
-			out << fv;
-			
-			desiredOutput = "---\n-\n  x: 5\n  bar: hello\n-\n  x: 3\n  bar: goodbye";
-		}
-		
-		template <typename T>
-		YAML::Emitter& operator << (YAML::Emitter& out, const T *v) {
-			if(v)
-				out << *v;
-			else
-				out << YAML::Null;
-			return out;
-		}
-		
-		void PointerToInt(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			int foo = 5;
-			int *bar = &foo;
-			int *baz = 0;
-			out << YAML::BeginSeq;
-			out << bar << baz;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n- 5\n- ~";
-		}
-
-		void PointerToUserType(YAML::Emitter& out, std::string& desiredOutput)
-		{
-			Foo foo(5, "hello");
-			Foo *bar = &foo;
-			Foo *baz = 0;
-			out << YAML::BeginSeq;
-			out << bar << baz;
-			out << YAML::EndSeq;
-			
-			desiredOutput = "---\n-\n  x: 5\n  bar: hello\n- ~";
-		}
-
-		////////////////////////////////////////////////////////////////////////////////////////////////////////
-		// incorrect emitting
-		
-		void ExtraEndSeq(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::UNEXPECTED_END_SEQ;
-
-			out << YAML::BeginSeq;
-			out << "Hello";
-			out << "World";
-			out << YAML::EndSeq;
-			out << YAML::EndSeq;
-		}
-
-		void ExtraEndMap(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::UNEXPECTED_END_MAP;
-			
-			out << YAML::BeginMap;
-			out << YAML::Key << "Hello" << YAML::Value << "World";
-			out << YAML::EndMap;
-			out << YAML::EndMap;
-		}
-
-		void BadSingleQuoted(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::SINGLE_QUOTED_CHAR;
-			
-			out << YAML::SingleQuoted << "Hello\nWorld";
-		}
-
-		void InvalidAnchor(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::INVALID_ANCHOR;
-			
-			out << YAML::BeginSeq;
-			out << YAML::Anchor("new\nline") << "Test";
-			out << YAML::EndSeq;
-		}
-		
-		void InvalidAlias(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::INVALID_ALIAS;
-			
-			out << YAML::BeginSeq;
-			out << YAML::Alias("new\nline");
-			out << YAML::EndSeq;
-		}
-
-		void MissingKey(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::EXPECTED_KEY_TOKEN;
-			
-			out << YAML::BeginMap;
-			out << YAML::Key << "key" << YAML::Value << "value";
-			out << "missing key" << YAML::Value << "value";
-			out << YAML::EndMap;
-		}
-		
-		void MissingValue(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::EXPECTED_VALUE_TOKEN;
-			
-			out << YAML::BeginMap;
-			out << YAML::Key << "key" << "value";
-			out << YAML::EndMap;
-		}
-
-		void UnexpectedKey(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::UNEXPECTED_KEY_TOKEN;
-			
-			out << YAML::BeginSeq;
-			out << YAML::Key << "hi";
-			out << YAML::EndSeq;
-		}
-		
-		void UnexpectedValue(YAML::Emitter& out, std::string& desiredError)
-		{
-			desiredError = YAML::ErrorMsg::UNEXPECTED_VALUE_TOKEN;
-			
-			out << YAML::BeginSeq;
-			out << YAML::Value << "hi";
-			out << YAML::EndSeq;
-		}
-	}
-	
-	namespace {
-		void RunEmitterTest(void (*test)(YAML::Emitter&, std::string&), const std::string& name, int& passed, int& total) {
-			YAML::Emitter out;
-			std::string desiredOutput;
-			test(out, desiredOutput);
-			std::string output = out.c_str();
-
-			if(output == desiredOutput) {
-				passed++;
-			} else {
-				std::cout << "Emitter test failed: " << name << "\n";
-				std::cout << "Output:\n";
-				std::cout << output << "<<<\n";
-				std::cout << "Desired output:\n";
-				std::cout << desiredOutput << "<<<\n";				
-			}
-			total++;
-		}
-		
-		void RunEmitterErrorTest(void (*test)(YAML::Emitter&, std::string&), const std::string& name, int& passed, int& total) {
-			YAML::Emitter out;
-			std::string desiredError;
-			test(out, desiredError);
-			std::string lastError = out.GetLastError();
-			if(!out.good() && lastError == desiredError) {
-				passed++;
-			} else {
-				std::cout << "Emitter test failed: " << name << "\n";
-				if(out.good())
-					std::cout << "No error detected\n";
-				else
-					std::cout << "Detected error: " << lastError << "\n";
-				std::cout << "Expected error: " << desiredError << "\n";
-			}
-			total++;
-		}
-	}
-	
-	bool RunEmitterTests()
-	{
-		int passed = 0;
-		int total = 0;
-		RunEmitterTest(&Emitter::SimpleScalar, "simple scalar", passed, total);
-		RunEmitterTest(&Emitter::SimpleSeq, "simple seq", passed, total);
-		RunEmitterTest(&Emitter::SimpleFlowSeq, "simple flow seq", passed, total);
-		RunEmitterTest(&Emitter::EmptyFlowSeq, "empty flow seq", passed, total);
-		RunEmitterTest(&Emitter::NestedBlockSeq, "nested block seq", passed, total);
-		RunEmitterTest(&Emitter::NestedFlowSeq, "nested flow seq", passed, total);
-		RunEmitterTest(&Emitter::SimpleMap, "simple map", passed, total);
-		RunEmitterTest(&Emitter::SimpleFlowMap, "simple flow map", passed, total);
-		RunEmitterTest(&Emitter::MapAndList, "map and list", passed, total);
-		RunEmitterTest(&Emitter::ListAndMap, "list and map", passed, total);
-		RunEmitterTest(&Emitter::NestedBlockMap, "nested block map", passed, total);
-		RunEmitterTest(&Emitter::NestedFlowMap, "nested flow map", passed, total);
-		RunEmitterTest(&Emitter::MapListMix, "map list mix", passed, total);
-		RunEmitterTest(&Emitter::SimpleLongKey, "simple long key", passed, total);
-		RunEmitterTest(&Emitter::SingleLongKey, "single long key", passed, total);
-		RunEmitterTest(&Emitter::ComplexLongKey, "complex long key", passed, total);
-		RunEmitterTest(&Emitter::AutoLongKey, "auto long key", passed, total);
-		RunEmitterTest(&Emitter::ScalarFormat, "scalar format", passed, total);
-		RunEmitterTest(&Emitter::AutoLongKeyScalar, "auto long key scalar", passed, total);
-		RunEmitterTest(&Emitter::LongKeyFlowMap, "long key flow map", passed, total);
-		RunEmitterTest(&Emitter::BlockMapAsKey, "block map as key", passed, total);
-		RunEmitterTest(&Emitter::AliasAndAnchor, "alias and anchor", passed, total);
-		RunEmitterTest(&Emitter::AliasAndAnchorWithNull, "alias and anchor with null", passed, total);
-		RunEmitterTest(&Emitter::SimpleVerbatimTag, "simple verbatim tag", passed, total);
-		RunEmitterTest(&Emitter::VerbatimTagInBlockSeq, "verbatim tag in block seq", passed, total);
-		RunEmitterTest(&Emitter::VerbatimTagInFlowSeq, "verbatim tag in flow seq", passed, total);
-		RunEmitterTest(&Emitter::VerbatimTagInFlowSeqWithNull, "verbatim tag in flow seq with null", passed, total);
-		RunEmitterTest(&Emitter::VerbatimTagInBlockMap, "verbatim tag in block map", passed, total);
-		RunEmitterTest(&Emitter::VerbatimTagInFlowMap, "verbatim tag in flow map", passed, total);
-		RunEmitterTest(&Emitter::VerbatimTagInFlowMapWithNull, "verbatim tag in flow map with null", passed, total);
-		RunEmitterTest(&Emitter::VerbatimTagWithEmptySeq, "verbatim tag with empty seq", passed, total);
-		RunEmitterTest(&Emitter::VerbatimTagWithEmptyMap, "verbatim tag with empty map", passed, total);
-		RunEmitterTest(&Emitter::VerbatimTagWithEmptySeqAndMap, "verbatim tag with empty seq and map", passed, total);
-		RunEmitterTest(&Emitter::ByKindTagWithScalar, "by-kind tag with scalar", passed, total);
-		RunEmitterTest(&Emitter::LocalTagWithScalar, "local tag with scalar", passed, total);
-		RunEmitterTest(&Emitter::ComplexDoc, "complex doc", passed, total);
-		RunEmitterTest(&Emitter::STLContainers, "STL containers", passed, total);
-		RunEmitterTest(&Emitter::SimpleComment, "simple comment", passed, total);
-		RunEmitterTest(&Emitter::MultiLineComment, "multi-line comment", passed, total);
-		RunEmitterTest(&Emitter::ComplexComments, "complex comments", passed, total);
-		RunEmitterTest(&Emitter::Indentation, "indentation", passed, total);
-		RunEmitterTest(&Emitter::SimpleGlobalSettings, "simple global settings", passed, total);
-		RunEmitterTest(&Emitter::ComplexGlobalSettings, "complex global settings", passed, total);
-		RunEmitterTest(&Emitter::Null, "null", passed, total);
-		RunEmitterTest(&Emitter::EscapedUnicode, "escaped unicode", passed, total);
-		RunEmitterTest(&Emitter::Unicode, "unicode", passed, total);
-		RunEmitterTest(&Emitter::DoubleQuotedUnicode, "double quoted unicode", passed, total);
-		RunEmitterTest(&Emitter::UserType, "user type", passed, total);
-		RunEmitterTest(&Emitter::UserTypeInContainer, "user type in container", passed, total);
-		RunEmitterTest(&Emitter::PointerToInt, "pointer to int", passed, total);
-		RunEmitterTest(&Emitter::PointerToUserType, "pointer to user type", passed, total);
-		
-		RunEmitterErrorTest(&Emitter::ExtraEndSeq, "extra EndSeq", passed, total);
-		RunEmitterErrorTest(&Emitter::ExtraEndMap, "extra EndMap", passed, total);
-		RunEmitterErrorTest(&Emitter::BadSingleQuoted, "bad single quoted string", passed, total);
-		RunEmitterErrorTest(&Emitter::InvalidAnchor, "invalid anchor", passed, total);
-		RunEmitterErrorTest(&Emitter::InvalidAlias, "invalid alias", passed, total);
-		RunEmitterErrorTest(&Emitter::MissingKey, "missing key", passed, total);
-		RunEmitterErrorTest(&Emitter::MissingValue, "missing value", passed, total);
-		RunEmitterErrorTest(&Emitter::UnexpectedKey, "unexpected key", passed, total);
-		RunEmitterErrorTest(&Emitter::UnexpectedValue, "unexpected value", passed, total);
-		RunEmitterErrorTest(&Emitter::BadLocalTag, "bad local tag", passed, total);
-
-		std::cout << "Emitter tests: " << passed << "/" << total << " passed\n";
-		return passed == total;
-	}
-}
-

test/emittertests.h

@@ -1,11 +0,0 @@
-#pragma once
-
-#ifndef EMITTERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define EMITTERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-namespace Test {
-	bool RunEmitterTests();
-}
-
-#endif // EMITTERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

test/main.cpp

@@ -1,7 +0,0 @@
-#include "tests.h"
-
-int main()
-{
-	Test::RunAll();
-	return 0;
-}

test/parsertests.h

@@ -1,11 +0,0 @@
-#pragma once
-
-#ifndef PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-namespace Test {
-	bool RunParserTests();
-}
-
-#endif // PARSERTESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

test/tests.cpp

@@ -1,29 +0,0 @@
-#include "tests.h"
-#include "emittertests.h"
-#include "parsertests.h"
-#include "spectests.h"
-#include "yaml.h"
-#include <fstream>
-#include <sstream>
-#include <vector>
-#include <iostream>
-
-namespace Test
-{
-	void RunAll()
-	{
-		bool passed = true;
-		if(!RunParserTests())
-			passed = false;
-			
-		if(!RunEmitterTests())
-			passed = false;
-
-		if(!RunSpecTests())
-			passed = false;
-		
-		if(passed)
-			std::cout << "All tests passed!\n";
-	}
-}
-

test/tests.h

@@ -1,51 +0,0 @@
-#pragma once
-
-#ifndef TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#include <string>
-
-namespace Test {
-	void RunAll();
-
-	namespace Parser {
-		// scalar tests
-		void SimpleScalar(std::string& inputScalar, std::string& desiredOutput);
-		void MultiLineScalar(std::string& inputScalar, std::string& desiredOutput);
-		void LiteralScalar(std::string& inputScalar, std::string& desiredOutput);
-		void FoldedScalar(std::string& inputScalar, std::string& desiredOutput);
-		void ChompedFoldedScalar(std::string& inputScalar, std::string& desiredOutput);
-		void ChompedLiteralScalar(std::string& inputScalar, std::string& desiredOutput);
-		void FoldedScalarWithIndent(std::string& inputScalar, std::string& desiredOutput);
-		void ColonScalar(std::string& inputScalar, std::string& desiredOutput);
-		void QuotedScalar(std::string& inputScalar, std::string& desiredOutput);
-		void CommaScalar(std::string& inputScalar, std::string& desiredOutput);
-		void DashScalar(std::string& inputScalar, std::string& desiredOutput);
-		void URLScalar(std::string& inputScalar, std::string& desiredOutput);
-
-		// misc tests
-		bool SimpleSeq();
-		bool SimpleMap();
-		bool FlowSeq();
-		bool FlowMap();
-		bool FlowMapWithOmittedKey();
-		bool FlowMapWithOmittedValue();
-		bool FlowMapWithSoloEntry();
-		bool FlowMapEndingWithSoloEntry();
-		bool QuotedSimpleKeys();
-		bool CompressedMapAndSeq();
-		bool NullBlockSeqEntry();
-		bool NullBlockMapKey();
-		bool NullBlockMapValue();
-		bool SimpleAlias();
-		bool AliasWithNull();
-		bool AnchorInSimpleKey();
-		bool AliasAsSimpleKey();
-		bool ExplicitDoc();
-		bool MultipleDocs();
-		bool ExplicitEndDoc();
-		bool MultipleDocsWithSomeExplicitIndicators();
-	}
-}
-
-#endif // TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

util/parse.cpp

@@ -1,25 +1,9 @@
 #include "yaml.h"
 #include <fstream>
 #include <iostream>
-#include <vector>
-
-struct Params {
-	bool hasFile;
-	std::string fileName;
-};
-
-Params ParseArgs(int argc, char **argv) {
-	Params p;
-
-	std::vector<char*> args(argv + 1, argv + argc);
-	
-	return p;
-}
 
 int main(int argc, char **argv)
 {
-	Params p = ParseArgs(argc, argv);
-
 	std::ifstream fin;
 	if(argc > 1)
 		fin.open(argv[1]);
@@ -27,8 +11,9 @@ int main(int argc, char **argv)
 	std::istream& input = (argc > 1 ? fin : std::cin);
 	try {
 		YAML::Parser parser(input);
-		YAML::Node doc;
-		while(parser.GetNextDocument(doc)) {
+		while(parser) {
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
 			YAML::Emitter emitter;
 			emitter << doc;
 			std::cout << emitter.c_str() << "\n";

yaml-reader.vcproj

@@ -2,9 +2,9 @@
 <VisualStudioProject
 	ProjectType="Visual C++"
 	Version="9.00"
-	Name="parse"
-	ProjectGUID="{CD007B57-7812-4930-A5E2-6E5E56338814}"
-	RootNamespace="parse"
+	Name="yaml-reader"
+	ProjectGUID="{E8CC0D8A-D784-4A6B-B78B-ACEA13F9FB0B}"
+	RootNamespace="yamlreader"
 	TargetFrameworkVersion="196613"
 	>
 	<Platforms>
@@ -39,15 +39,13 @@
 			/>
 			<Tool
 				Name="VCCLCompilerTool"
-				AdditionalOptions="/D_SCL_SECURE_NO_WARNINGS"
 				Optimization="0"
 				AdditionalIncludeDirectories="include"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"
 				WarningLevel="3"
-				DebugInformationFormat="4"
-				DisableSpecificWarnings="4127;4355"
+				DebugInformationFormat="3"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -112,15 +110,13 @@
 			/>
 			<Tool
 				Name="VCCLCompilerTool"
-				AdditionalOptions="/D_SCL_SECURE_NO_WARNINGS"
 				Optimization="2"
 				EnableIntrinsicFunctions="true"
 				AdditionalIncludeDirectories="include"
 				RuntimeLibrary="2"
 				EnableFunctionLevelLinking="true"
-				WarningLevel="3"
+				WarningLevel="4"
 				DebugInformationFormat="3"
-				DisableSpecificWarnings="4127;4355"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -172,7 +168,19 @@
 			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
 			>
 			<File
-				RelativePath=".\util\parse.cpp"
+				RelativePath=".\yaml-reader\emittertests.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\yaml-reader\main.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\yaml-reader\parsertests.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\yaml-reader\tests.cpp"
 				>
 			</File>
 		</Filter>
@@ -181,12 +189,10 @@
 			Filter="h;hpp;hxx;hm;inl;inc;xsd"
 			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
 			>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
+			<File
+				RelativePath=".\yaml-reader\tests.h"
+				>
+			</File>
 		</Filter>
 	</Files>
 	<Globals>

yaml-reader/CMakeLists.txt

@@ -0,0 +1,10 @@
+file(GLOB yaml-reader_headers *.h)
+file(GLOB yaml-reader_sources *.cpp)
+
+add_executable(yaml-reader
+	${yaml-reader_sources}
+	${yaml-reader_headers}
+)
+target_link_libraries(yaml-reader yaml-cpp)
+
+add_test(yaml-reader-test yaml-reader)

yaml-reader/emittertests.cpp

@@ -0,0 +1,537 @@
+#include "tests.h"
+#include "yaml.h"
+
+namespace Test
+{
+	namespace Emitter {
+		////////////////////////////////////////////////////////////////////////////////////////////////////////
+		// correct emitting
+
+		void SimpleScalar(YAML::Emitter& out, std::string& desiredOutput) {
+			out << "Hello, World!";
+			desiredOutput = "Hello, World!";
+		}
+		
+		void SimpleSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginSeq;
+			out << "eggs";
+			out << "bread";
+			out << "milk";
+			out << YAML::EndSeq;
+
+			desiredOutput = "- eggs\n- bread\n- milk";
+		}
+		
+		void SimpleFlowSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::Flow;
+			out << YAML::BeginSeq;
+			out << "Larry";
+			out << "Curly";
+			out << "Moe";
+			out << YAML::EndSeq;
+			
+			desiredOutput = "[Larry, Curly, Moe]";
+		}
+		
+		void EmptyFlowSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::Flow;
+			out << YAML::BeginSeq;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "[]";
+		}
+		
+		void NestedBlockSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginSeq;
+			out << "item 1";
+			out << YAML::BeginSeq << "subitem 1" << "subitem 2" << YAML::EndSeq;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- item 1\n-\n  - subitem 1\n  - subitem 2";
+		}
+		
+		void NestedFlowSeq(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginSeq;
+			out << "one";
+			out << YAML::Flow << YAML::BeginSeq << "two" << "three" << YAML::EndSeq;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- one\n- [two, three]";
+		}
+
+		void SimpleMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Ryan Braun";
+			out << YAML::Key << "position";
+			out << YAML::Value << "3B";
+			out << YAML::EndMap;
+
+			desiredOutput = "name: Ryan Braun\nposition: 3B";
+		}
+		
+		void SimpleFlowMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::Flow;
+			out << YAML::BeginMap;
+			out << YAML::Key << "shape";
+			out << YAML::Value << "square";
+			out << YAML::Key << "color";
+			out << YAML::Value << "blue";
+			out << YAML::EndMap;
+			
+			desiredOutput = "{shape: square, color: blue}";
+		}
+		
+		void MapAndList(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Barack Obama";
+			out << YAML::Key << "children";
+			out << YAML::Value << YAML::BeginSeq << "Sasha" << "Malia" << YAML::EndSeq;
+			out << YAML::EndMap;
+
+			desiredOutput = "name: Barack Obama\nchildren:\n  - Sasha\n  - Malia";
+		}
+		
+		void ListAndMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginSeq;
+			out << "item 1";
+			out << YAML::BeginMap;
+			out << YAML::Key << "pens" << YAML::Value << 8;
+			out << YAML::Key << "pencils" << YAML::Value << 14;
+			out << YAML::EndMap;
+			out << "item 2";
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- item 1\n-\n  pens: 8\n  pencils: 14\n- item 2";
+		}
+
+		void NestedBlockMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Fred";
+			out << YAML::Key << "grades";
+			out << YAML::Value;
+			out << YAML::BeginMap;
+			out << YAML::Key << "algebra" << YAML::Value << "A";
+			out << YAML::Key << "physics" << YAML::Value << "C+";
+			out << YAML::Key << "literature" << YAML::Value << "B";
+			out << YAML::EndMap;
+			out << YAML::EndMap;
+			
+			desiredOutput = "name: Fred\ngrades:\n  algebra: A\n  physics: C+\n  literature: B";
+		}
+
+		void NestedFlowMap(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::Flow;
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Fred";
+			out << YAML::Key << "grades";
+			out << YAML::Value;
+			out << YAML::BeginMap;
+			out << YAML::Key << "algebra" << YAML::Value << "A";
+			out << YAML::Key << "physics" << YAML::Value << "C+";
+			out << YAML::Key << "literature" << YAML::Value << "B";
+			out << YAML::EndMap;
+			out << YAML::EndMap;
+			
+			desiredOutput = "{name: Fred, grades: {algebra: A, physics: C+, literature: B}}";
+		}
+		
+		void MapListMix(YAML::Emitter& out, std::string& desiredOutput) {
+			out << YAML::BeginMap;
+			out << YAML::Key << "name";
+			out << YAML::Value << "Bob";
+			out << YAML::Key << "position";
+			out << YAML::Value;
+			out << YAML::Flow << YAML::BeginSeq << 2 << 4 << YAML::EndSeq;
+			out << YAML::Key << "invincible" << YAML::Value << YAML::OnOffBool << false;
+			out << YAML::EndMap;
+			
+			desiredOutput = "name: Bob\nposition: [2, 4]\ninvincible: off";
+		}
+
+		void SimpleLongKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::LongKey;
+			out << YAML::BeginMap;
+			out << YAML::Key << "height";
+			out << YAML::Value << "5'9\"";
+			out << YAML::Key << "weight";
+			out << YAML::Value << 145;
+			out << YAML::EndMap;
+			
+			desiredOutput = "? height\n: 5'9\"\n? weight\n: 145";
+		}
+		
+		void SingleLongKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << "age";
+			out << YAML::Value << "24";
+			out << YAML::LongKey << YAML::Key << "height";
+			out << YAML::Value << "5'9\"";
+			out << YAML::Key << "weight";
+			out << YAML::Value << 145;
+			out << YAML::EndMap;
+			
+			desiredOutput = "age: 24\n? height\n: 5'9\"\nweight: 145";
+		}
+		
+		void ComplexLongKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::LongKey;
+			out << YAML::BeginMap;
+			out << YAML::Key << YAML::BeginSeq << 1 << 3 << YAML::EndSeq;
+			out << YAML::Value << "monster";
+			out << YAML::Key << YAML::Flow << YAML::BeginSeq << 2 << 0 << YAML::EndSeq;
+			out << YAML::Value << "demon";
+			out << YAML::EndMap;
+			
+			desiredOutput = "?\n  - 1\n  - 3\n: monster\n? [2, 0]\n: demon";
+		}
+
+		void AutoLongKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << YAML::BeginSeq << 1 << 3 << YAML::EndSeq;
+			out << YAML::Value << "monster";
+			out << YAML::Key << YAML::Flow << YAML::BeginSeq << 2 << 0 << YAML::EndSeq;
+			out << YAML::Value << "demon";
+			out << YAML::Key << "the origin";
+			out << YAML::Value << "angel";
+			out << YAML::EndMap;
+			
+			desiredOutput = "?\n  - 1\n  - 3\n: monster\n? [2, 0]\n: demon\nthe origin: angel";
+		}
+		
+		void ScalarFormat(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << "simple scalar";
+			out << YAML::SingleQuoted << "explicit single-quoted scalar";
+			out << YAML::DoubleQuoted << "explicit double-quoted scalar";
+			out << "auto-detected\ndouble-quoted scalar";
+			out << "a non-\"auto-detected\" double-quoted scalar";
+			out << YAML::Literal << "literal scalar\nthat may span\nmany, many\nlines and have \"whatever\" crazy\tsymbols that we like";
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- simple scalar\n- 'explicit single-quoted scalar'\n- \"explicit double-quoted scalar\"\n- \"auto-detected\\x0adouble-quoted scalar\"\n- a non-\"auto-detected\" double-quoted scalar\n- |\n  literal scalar\n  that may span\n  many, many\n  lines and have \"whatever\" crazy\tsymbols that we like";
+		}
+
+		void AutoLongKeyScalar(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << YAML::Literal << "multi-line\nscalar";
+			out << YAML::Value << "and its value";
+			out << YAML::EndMap;
+			
+			desiredOutput = "? |\n  multi-line\n  scalar\n: and its value";
+		}
+		
+		void LongKeyFlowMap(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::Flow;
+			out << YAML::BeginMap;
+			out << YAML::Key << "simple key";
+			out << YAML::Value << "and value";
+			out << YAML::LongKey << YAML::Key << "long key";
+			out << YAML::Value << "and its value";
+			out << YAML::EndMap;
+			
+			desiredOutput = "{simple key: and value, ? long key: and its value}";
+		}
+
+		void BlockMapAsKey(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key;
+			out << YAML::BeginMap;
+			out << YAML::Key << "key" << YAML::Value << "value";
+			out << YAML::Key << "next key" << YAML::Value << "next value";
+			out << YAML::EndMap;
+			out << YAML::Value;
+			out << "total value";
+			out << YAML::EndMap;
+			
+			desiredOutput = "?\n  key: value\n  next key: next value\n: total value";
+		}
+		
+		void AliasAndAnchor(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << YAML::Anchor("fred");
+			out << YAML::BeginMap;
+			out << YAML::Key << "name" << YAML::Value << "Fred";
+			out << YAML::Key << "age" << YAML::Value << 42;
+			out << YAML::EndMap;
+			out << YAML::Alias("fred");
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- &fred\n  name: Fred\n  age: 42\n- *fred";
+		}
+
+		void AliasAndAnchorWithNull(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << YAML::Anchor("fred") << YAML::Null;
+			out << YAML::Alias("fred");
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- &fred ~\n- *fred";
+		}
+
+		void ComplexDoc(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << "receipt";
+			out << YAML::Value << "Oz-Ware Purchase Invoice";
+			out << YAML::Key << "date";
+			out << YAML::Value << "2007-08-06";
+			out << YAML::Key << "customer";
+			out << YAML::Value;
+			out << YAML::BeginMap;
+			out << YAML::Key << "given";
+			out << YAML::Value << "Dorothy";
+			out << YAML::Key << "family";
+			out << YAML::Value << "Gale";
+			out << YAML::EndMap;
+			out << YAML::Key << "items";
+			out << YAML::Value;
+			out << YAML::BeginSeq;
+			out << YAML::BeginMap;
+			out << YAML::Key << "part_no";
+			out << YAML::Value << "A4786";
+			out << YAML::Key << "descrip";
+			out << YAML::Value << "Water Bucket (Filled)";
+			out << YAML::Key << "price";
+			out << YAML::Value << 1.47;
+			out << YAML::Key << "quantity";
+			out << YAML::Value << 4;
+			out << YAML::EndMap;
+			out << YAML::BeginMap;
+			out << YAML::Key << "part_no";
+			out << YAML::Value << "E1628";
+			out << YAML::Key << "descrip";
+			out << YAML::Value << "High Heeled \"Ruby\" Slippers";
+			out << YAML::Key << "price";
+			out << YAML::Value << 100.27;
+			out << YAML::Key << "quantity";
+			out << YAML::Value << 1;
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			out << YAML::Key << "bill-to";
+			out << YAML::Value << YAML::Anchor("id001");
+			out << YAML::BeginMap;
+			out << YAML::Key << "street";
+			out << YAML::Value << YAML::Literal << "123 Tornado Alley\nSuite 16";
+			out << YAML::Key << "city";
+			out << YAML::Value << "East Westville";
+			out << YAML::Key << "state";
+			out << YAML::Value << "KS";
+			out << YAML::EndMap;
+			out << YAML::Key << "ship-to";
+			out << YAML::Value << YAML::Alias("id001");
+			out << YAML::EndMap;
+			
+			desiredOutput = "receipt: Oz-Ware Purchase Invoice\ndate: 2007-08-06\ncustomer:\n  given: Dorothy\n  family: Gale\nitems:\n  -\n    part_no: A4786\n    descrip: Water Bucket (Filled)\n    price: 1.47\n    quantity: 4\n  -\n    part_no: E1628\n    descrip: High Heeled \"Ruby\" Slippers\n    price: 100.27\n    quantity: 1\nbill-to: &id001\n  street: |\n    123 Tornado Alley\n    Suite 16\n  city: East Westville\n  state: KS\nship-to: *id001";
+		}
+
+		void STLContainers(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			std::vector <int> primes;
+			primes.push_back(2);
+			primes.push_back(3);
+			primes.push_back(5);
+			primes.push_back(7);
+			primes.push_back(11);
+			primes.push_back(13);
+			out << YAML::Flow << primes;
+			std::map <std::string, int> ages;
+			ages["Daniel"] = 26;
+			ages["Jesse"] = 24;
+			out << ages;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- [2, 3, 5, 7, 11, 13]\n-\n  Daniel: 26\n  Jesse: 24";
+		}
+
+		void SimpleComment(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::Key << "method";
+			out << YAML::Value << "least squares" << YAML::Comment("should we change this method?");
+			out << YAML::EndMap;
+			
+			desiredOutput = "method: least squares  # should we change this method?";
+		}
+
+		void MultiLineComment(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << "item 1" << YAML::Comment("really really long\ncomment that couldn't possibly\nfit on one line");
+			out << "item 2";
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- item 1  # really really long\n          # comment that couldn't possibly\n          # fit on one line\n- item 2";
+		}
+
+		void ComplexComments(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginMap;
+			out << YAML::LongKey << YAML::Key << "long key" << YAML::Comment("long key");
+			out << YAML::Value << "value";
+			out << YAML::EndMap;
+			
+			desiredOutput = "? long key  # long key\n: value";
+		}
+
+		void Indentation(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::Indent(4);
+			out << YAML::BeginSeq;
+			out << YAML::BeginMap;
+			out << YAML::Key << "key 1" << YAML::Value << "value 1";
+			out << YAML::Key << "key 2" << YAML::Value << YAML::BeginSeq << "a" << "b" << "c" << YAML::EndSeq;
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "-\n    key 1: value 1\n    key 2:\n        - a\n        - b\n        - c";
+		}
+
+		void SimpleGlobalSettings(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out.SetIndent(4);
+			out.SetMapFormat(YAML::LongKey);
+
+			out << YAML::BeginSeq;
+			out << YAML::BeginMap;
+			out << YAML::Key << "key 1" << YAML::Value << "value 1";
+			out << YAML::Key << "key 2" << YAML::Value << YAML::Flow << YAML::BeginSeq << "a" << "b" << "c" << YAML::EndSeq;
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "-\n    ? key 1\n    : value 1\n    ? key 2\n    : [a, b, c]";
+		}
+		
+		void ComplexGlobalSettings(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << YAML::Block;
+			out << YAML::BeginMap;
+			out << YAML::Key << "key 1" << YAML::Value << "value 1";
+			out << YAML::Key << "key 2" << YAML::Value;
+			out.SetSeqFormat(YAML::Flow);
+			out << YAML::BeginSeq << "a" << "b" << "c" << YAML::EndSeq;
+			out << YAML::EndMap;
+			out << YAML::BeginMap;
+			out << YAML::Key << YAML::BeginSeq << 1 << 2 << YAML::EndSeq;
+			out << YAML::Value << YAML::BeginMap << YAML::Key << "a" << YAML::Value << "b" << YAML::EndMap;
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "-\n  key 1: value 1\n  key 2: [a, b, c]\n-\n  ? [1, 2]\n  :\n    a: b";
+		}
+
+		void Null(YAML::Emitter& out, std::string& desiredOutput)
+		{
+			out << YAML::BeginSeq;
+			out << YAML::Null;
+			out << YAML::BeginMap;
+			out << YAML::Key << "null value" << YAML::Value << YAML::Null;
+			out << YAML::Key << YAML::Null << YAML::Value << "null key";
+			out << YAML::EndMap;
+			out << YAML::EndSeq;
+			
+			desiredOutput = "- ~\n-\n  null value: ~\n  ~: null key";
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////////////////////////
+		// incorrect emitting
+		
+		void ExtraEndSeq(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::UNEXPECTED_END_SEQ;
+
+			out << YAML::BeginSeq;
+			out << "Hello";
+			out << "World";
+			out << YAML::EndSeq;
+			out << YAML::EndSeq;
+		}
+
+		void ExtraEndMap(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::UNEXPECTED_END_MAP;
+			
+			out << YAML::BeginMap;
+			out << YAML::Key << "Hello" << YAML::Value << "World";
+			out << YAML::EndMap;
+			out << YAML::EndMap;
+		}
+
+		void BadSingleQuoted(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::SINGLE_QUOTED_CHAR;
+			
+			out << YAML::SingleQuoted << "Hello\nWorld";
+		}
+
+		void InvalidAnchor(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::INVALID_ANCHOR;
+			
+			out << YAML::BeginSeq;
+			out << YAML::Anchor("new\nline") << "Test";
+			out << YAML::EndSeq;
+		}
+		
+		void InvalidAlias(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::INVALID_ALIAS;
+			
+			out << YAML::BeginSeq;
+			out << YAML::Alias("new\nline");
+			out << YAML::EndSeq;
+		}
+
+		void MissingKey(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::EXPECTED_KEY_TOKEN;
+			
+			out << YAML::BeginMap;
+			out << YAML::Key << "key" << YAML::Value << "value";
+			out << "missing key" << YAML::Value << "value";
+			out << YAML::EndMap;
+		}
+		
+		void MissingValue(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::EXPECTED_VALUE_TOKEN;
+			
+			out << YAML::BeginMap;
+			out << YAML::Key << "key" << "value";
+			out << YAML::EndMap;
+		}
+
+		void UnexpectedKey(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::UNEXPECTED_KEY_TOKEN;
+			
+			out << YAML::BeginSeq;
+			out << YAML::Key << "hi";
+			out << YAML::EndSeq;
+		}
+		
+		void UnexpectedValue(YAML::Emitter& out, std::string& desiredError)
+		{
+			desiredError = YAML::ErrorMsg::UNEXPECTED_VALUE_TOKEN;
+			
+			out << YAML::BeginSeq;
+			out << YAML::Value << "hi";
+			out << YAML::EndSeq;
+		}
+	}
+}

yaml-reader/main.cpp

@@ -0,0 +1,11 @@
+#include "tests.h"
+
+int main()
+{
+#ifdef WINDOWS
+	_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);
+#endif // WINDOWS
+	Test::RunAll();
+
+	return 0;
+}

yaml-reader/parsertests.cpp

@@ -0,0 +1,614 @@
+#include "tests.h"
+#include "yaml.h"
+#include <sstream>
+#include <algorithm>
+
+namespace Test
+{
+	namespace Parser {
+		void SimpleScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "Hello, World!";
+			desiredOutput = "Hello, World!";
+		}
+
+		void MultiLineScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				"normal scalar, but\n"
+				"over several lines";
+			desiredOutput = "normal scalar, but over several lines";
+		}
+
+		void LiteralScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				"|\n"
+				" literal scalar - so we can draw ASCII:\n"
+				" \n"
+                "          -   -\n"
+                "         |  -  |\n"
+                "          -----\n";
+			desiredOutput =
+				"literal scalar - so we can draw ASCII:\n"
+				"\n"
+                "         -   -\n"
+                "        |  -  |\n"
+                "         -----\n";
+		}
+
+		void FoldedScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				">\n"
+				" and a folded scalar... so we\n"
+				" can just keep writing various\n"
+				" things. And if we want to keep indentation:\n"
+				" \n"
+				"    we just indent a little\n"
+				"    see, this stays indented";
+			desiredOutput =
+				"and a folded scalar... so we"
+				" can just keep writing various"
+				" things. And if we want to keep indentation:\n"
+				"\n"
+				"   we just indent a little\n"
+				"   see, this stays indented";
+		}
+
+		void ChompedFoldedScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				">-\n"
+				"  Here's a folded scalar\n"
+				"  that gets chomped.";
+			desiredOutput =
+				"Here's a folded scalar"
+				" that gets chomped.";
+		}
+
+		void ChompedLiteralScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				"|-\n"
+				"  Here's a literal scalar\n"
+				"  that gets chomped.";
+			desiredOutput =
+				"Here's a literal scalar\n"
+				"that gets chomped.";
+		}
+
+		void FoldedScalarWithIndent(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar =
+				">2\n"
+				"       Here's a folded scalar\n"
+				"  that starts with some indentation.";
+			desiredOutput =
+				"     Here's a folded scalar\n"
+				"that starts with some indentation.";
+		}
+
+		void ColonScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "::vector";
+			desiredOutput = "::vector";
+		}
+
+		void QuotedScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "\": - ()\"";
+			desiredOutput = ": - ()";
+		}
+
+		void CommaScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "Up, up, and away!";
+			desiredOutput = "Up, up, and away!";
+		}
+
+		void DashScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "-123";
+			desiredOutput = "-123";
+		}
+
+		void URLScalar(std::string& inputScalar, std::string& desiredOutput)
+		{
+			inputScalar = "http://example.com/foo#bar";
+			desiredOutput = "http://example.com/foo#bar";
+		}
+
+		bool SimpleSeq()
+		{
+			std::string input =
+				"- eggs\n"
+				"- bread\n"
+				"- milk";
+
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc[0] >> output;
+			if(output != "eggs")
+				return false;
+			doc[1] >> output;
+			if(output != "bread")
+				return false;
+			doc[2] >> output;
+			if(output != "milk")
+				return false;
+
+			return true;
+		}
+
+		bool SimpleMap()
+		{
+			std::string input =
+				"name: Prince Fielder\n"
+				"position: 1B\n"
+				"bats: L";
+
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc["name"] >> output;
+			if(output != "Prince Fielder")
+				return false;
+			doc["position"] >> output;
+			if(output != "1B")
+				return false;
+			doc["bats"] >> output;
+			if(output != "L")
+				return false;
+
+			return true;
+		}
+
+		bool FlowSeq()
+		{
+			std::string input = "[ 2 , 3, 5  ,  7,   11]";
+
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			int output;
+			doc[0] >> output;
+			if(output != 2)
+				return false;
+			doc[1] >> output;
+			if(output != 3)
+				return false;
+			doc[2] >> output;
+			if(output != 5)
+				return false;
+			doc[3] >> output;
+			if(output != 7)
+				return false;
+			doc[4] >> output;
+			if(output != 11)
+				return false;
+
+			return true;
+		}
+
+		bool FlowMap()
+		{
+			std::string input = "{hr: 65, avg: 0.278}";
+
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc["hr"] >> output;
+			if(output != "65")
+				return false;
+			doc["avg"] >> output;
+			if(output != "0.278")
+				return false;
+
+			return true;
+		}
+
+		bool FlowMapWithOmittedKey()
+		{
+			std::string input = "{: omitted key}";
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc[YAML::Null] >> output;
+			if(output != "omitted key")
+				return false;
+			
+			return true;
+		}
+		
+		bool FlowMapWithOmittedValue()
+		{
+			std::string input = "{a: b, c:, d:}";
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc["a"] >> output;
+			if(output != "b")
+				return false;
+			if(!IsNull(doc["c"]))
+				return false;
+			if(!IsNull(doc["d"]))
+				return false;
+
+			return true;
+		}
+
+		bool FlowMapWithSoloEntry()
+		{
+			std::string input = "{a: b, c, d: e}";
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc["a"] >> output;
+			if(output != "b")
+				return false;
+			if(!IsNull(doc["c"]))
+				return false;
+			doc["d"] >> output;
+			if(output != "e")
+				return false;
+			
+			return true;
+		}
+		
+		bool FlowMapEndingWithSoloEntry()
+		{
+			std::string input = "{a: b, c}";
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc["a"] >> output;
+			if(output != "b")
+				return false;
+			if(!IsNull(doc["c"]))
+				return false;
+			
+			return true;
+		}
+		
+		bool QuotedSimpleKeys()
+		{
+			std::string KeyValue[3] = { "\"double\": double\n", "'single': single\n", "plain: plain\n" };
+			
+			int perm[3] = { 0, 1, 2 };
+			do {
+				std::string input = KeyValue[perm[0]] + KeyValue[perm[1]] + KeyValue[perm[2]];
+
+				std::stringstream stream(input);
+				YAML::Parser parser(stream);
+				YAML::Node doc;
+				parser.GetNextDocument(doc);
+				
+				std::string output;
+				doc["double"] >> output;
+				if(output != "double")
+					return false;
+				doc["single"] >> output;
+				if(output != "single")
+					return false;
+				doc["plain"] >> output;
+				if(output != "plain")
+					return false;
+			} while(std::next_permutation(perm, perm + 3));
+				
+			return true;
+		}
+
+		bool CompressedMapAndSeq()
+		{
+			std::string input = "key:\n- one\n- two";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			const YAML::Node& seq = doc["key"];
+			if(seq.size() != 2)
+				return false;
+				
+			std::string output;
+			seq[0] >> output;
+			if(output != "one")
+				return false;
+			seq[1] >> output;
+			if(output != "two")
+				return false;
+
+			return true;
+		}
+
+		bool NullBlockSeqEntry()
+		{
+			std::string input = "- hello\n-\n- world";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "hello")
+				return false;
+			if(!IsNull(doc[1]))
+				return false;
+			doc[2] >> output;
+			if(output != "world")
+				return false;
+			
+			return true;
+		}
+		
+		bool NullBlockMapKey()
+		{
+			std::string input = ": empty key";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc[YAML::Null] >> output;
+			if(output != "empty key")
+				return false;
+			
+			return true;
+		}
+		
+		bool NullBlockMapValue()
+		{
+			std::string input = "empty value:";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(!IsNull(doc["empty value"]))
+				return false;
+			
+			return true;
+		}
+
+		bool SimpleAlias()
+		{
+			std::string input = "- &alias test\n- *alias";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "test")
+				return false;
+			
+			doc[1] >> output;
+			if(output != "test")
+				return false;
+			
+			if(doc.size() != 2)
+				return false;
+			
+			return true;
+		}
+		
+		bool AliasWithNull()
+		{
+			std::string input = "- &alias\n- *alias";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(!IsNull(doc[0]))
+				return false;
+			
+			if(!IsNull(doc[1]))
+				return false;
+			
+			if(doc.size() != 2)
+				return false;
+			
+			return true;
+		}
+
+		bool AnchorInSimpleKey()
+		{
+			std::string input = "- &a b: c\n- *a";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(doc.size() != 2)
+				return false;
+	
+			std::string output;
+			doc[0]["b"] >> output;
+			if(output != "c")
+				return false;
+			
+			doc[1] >> output;
+			if(output != "b")
+				return false;
+			
+			return true;
+		}
+		
+		bool AliasAsSimpleKey()
+		{
+			std::string input = "- &a b\n- *a: c";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			if(doc.size() != 2)
+				return false;
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "b")
+				return false;
+			
+			doc[1]["b"] >> output;
+			if(output != "c")
+				return false;
+
+			return true;
+		}
+		
+		bool ExplicitDoc()
+		{
+			std::string input = "---\n- one\n- two";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(doc.size() != 2)
+				return false;
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "one")
+				return false;
+			doc[1] >> output;
+			if(output != "two")
+				return false;
+			
+			return true;
+		}
+
+		bool MultipleDocs()
+		{
+			std::string input = "---\nname: doc1\n---\nname: doc2";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc["name"] >> output;
+			if(output != "doc1")
+				return false;
+			
+			if(!parser)
+				return false;
+			
+			parser.GetNextDocument(doc);
+			doc["name"] >> output;
+			if(output != "doc2")
+				return false;
+			
+			return true;
+		}
+		
+		bool ExplicitEndDoc()
+		{
+			std::string input = "- one\n- two\n...\n...";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(doc.size() != 2)
+				return false;
+			
+			std::string output;
+			doc[0] >> output;
+			if(output != "one")
+				return false;
+			doc[1] >> output;
+			if(output != "two")
+				return false;
+			
+			return true;
+		}
+		
+		bool MultipleDocsWithSomeExplicitIndicators()
+		{
+			std::string input =
+				"- one\n- two\n...\n"
+				"---\nkey: value\n...\n...\n"
+				"- three\n- four\n"
+				"---\nkey: value";
+			
+			std::stringstream stream(input);
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			std::string output;
+
+			parser.GetNextDocument(doc);
+			if(doc.size() != 2)
+				return false;
+			doc[0] >> output;
+			if(output != "one")
+				return false;
+			doc[1] >> output;
+			if(output != "two")
+				return false;
+			
+			parser.GetNextDocument(doc);
+			doc["key"] >> output;
+			if(output != "value")
+				return false;
+			
+			parser.GetNextDocument(doc);
+			if(doc.size() != 2)
+				return false;
+			doc[0] >> output;
+			if(output != "three")
+				return false;
+			doc[1] >> output;
+			if(output != "four")
+				return false;
+			
+			parser.GetNextDocument(doc);
+			doc["key"] >> output;
+			if(output != "value")
+				return false;
+			
+			return true;
+		}
+	}
+}

yaml-reader/spectests.cpp

@@ -0,0 +1,91 @@
+#include "spectests.h"
+#include "yaml.h"
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <iostream>
+
+namespace Test {
+	namespace {
+		void RunSpecTest(bool (*test)(), const std::string& index, const std::string& name, bool& passed) {
+			std::string error;
+			bool ok = true;
+			try {
+				ok = test();
+			} catch(const YAML::Exception& e) {
+				ok = false;
+				error = e.msg;
+			}
+			if(ok) {
+				std::cout << "Spec test " << index << " passed: " << name << "\n";
+			} else {
+				passed = false;
+				std::cout << "Spec test " << index << " failed: " << name << "\n";
+				if(error != "")
+					std::cout << "Caught exception: " << error << "\n";
+			}
+		}
+	}
+
+	namespace Spec {
+		bool SeqScalars() {
+			std::string input =
+				"- Mark McGwire\n"
+				"- Sammy Sosa\n"
+				"- Ken Griffey";
+			std::stringstream stream(input);
+			
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+			
+			if(doc.size() != 3)
+				return false;
+			std::string output;
+			doc[0] >> output;
+			if(output != "Mark McGwire")
+				return false;
+			doc[1] >> output;
+			if(output != "Sammy Sosa")
+				return false;
+			doc[2] >> output;
+			if(output != "Ken Griffey")
+				return false;
+			return true;
+		}
+		
+		bool MappingScalarsToScalars() {
+			std::string input =
+				"hr:  65    # Home runs\n"
+				"avg: 0.278 # Batting average\n"
+				"rbi: 147   # Runs Batted In";
+			std::stringstream stream(input);
+			
+			YAML::Parser parser(stream);
+			YAML::Node doc;
+			parser.GetNextDocument(doc);
+
+			std::string output;
+			doc["hr"] >> output;
+			if(output != "65")
+				return false;
+			doc["avg"] >> output;
+			if(output != "0.278")
+				return false;
+			doc["rbi"] >> output;
+			if(output != "147")
+				return false;
+			return true;
+		}
+	}
+
+	bool RunSpecTests()
+	{
+		bool passed = true;
+		RunSpecTest(&Spec::SeqScalars, "2.1", "Sequence of Scalars", passed);
+		RunSpecTest(&Spec::MappingScalarsToScalars, "2.2", "Mapping Scalars to Scalars", passed);
+		return passed;
+	}
+	
+}
+

yaml-reader/tests.cpp

@@ -0,0 +1,389 @@
+#include "tests.h"
+#include "spectests.h"
+#include "yaml.h"
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <iostream>
+
+namespace Test
+{
+	void RunAll()
+	{
+		bool passed = true;
+		if(!RunParserTests())
+			passed = false;
+			
+		if(!RunSpecTests())
+			passed = false;
+		
+		if(!RunEmitterTests())
+			passed = false;
+
+		if(passed)
+			std::cout << "All tests passed!\n";
+	}
+	
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Parser tests
+
+	namespace {
+		void RunScalarParserTest(void (*test)(std::string&, std::string&), const std::string& name, bool& passed) {
+			std::string error;
+			std::string inputScalar, desiredOutput;
+			std::string output;
+			bool ok = true;
+			try {
+				test(inputScalar, desiredOutput);
+				std::stringstream stream(inputScalar);
+				YAML::Parser parser(stream);
+				YAML::Node doc;
+				parser.GetNextDocument(doc);
+				doc >> output;
+			} catch(const YAML::Exception& e) {
+				ok = false;
+				error = e.msg;
+			}
+			if(ok && output == desiredOutput) {
+				std::cout << "Parser test passed: " << name << "\n";
+			} else {
+				passed = false;
+				std::cout << "Parser test failed: " << name << "\n";
+				if(error != "")
+					std::cout << "Caught exception: " << error << "\n";
+				else {
+					std::cout << "Output:\n" << output << "<<<\n";
+					std::cout << "Desired output:\n" << desiredOutput << "<<<\n";
+				}
+			}
+		}
+
+		void RunParserTest(bool (*test)(), const std::string& name, bool& passed) {
+			std::string error;
+			bool ok = true;
+			try {
+				ok = test();
+			} catch(const YAML::Exception& e) {
+				ok = false;
+				error = e.msg;
+			}
+			if(ok) {
+				std::cout << "Parser test passed: " << name << "\n";
+			} else {
+				passed = false;
+				std::cout << "Parser test failed: " << name << "\n";
+				if(error != "")
+					std::cout << "Caught exception: " << error << "\n";
+			}
+		}
+
+		typedef void (*EncodingFn)(std::ostream&, int);
+
+		inline char Byte(int ch)
+		{
+			return static_cast<char>(static_cast<unsigned char>(static_cast<unsigned int>(ch)));
+		}
+
+		void EncodeToUtf8(std::ostream& stream, int ch)
+		{
+			if (ch <= 0x7F)
+			{
+				stream << Byte(ch);
+			}
+			else if (ch <= 0x7FF)
+			{
+				stream << Byte(0xC0 | (ch >> 6));
+				stream << Byte(0x80 | (ch & 0x3F));
+			}
+			else if (ch <= 0xFFFF)
+			{
+				stream << Byte(0xE0 | (ch >> 12));
+				stream << Byte(0x80 | ((ch >> 6) & 0x3F));
+				stream << Byte(0x80 | (ch & 0x3F));
+			}
+			else if (ch <= 0x1FFFFF)
+			{
+				stream << Byte(0xF0 | (ch >> 18));
+				stream << Byte(0x80 | ((ch >> 12) & 0x3F));
+				stream << Byte(0x80 | ((ch >> 6) & 0x3F));
+				stream << Byte(0x80 | (ch & 0x3F));
+			}
+		}
+
+		bool SplitUtf16HighChar(std::ostream& stream, EncodingFn encoding, int ch)
+		{
+			int biasedValue = ch - 0x10000;
+			if (biasedValue < 0)
+			{
+				return false;
+			}
+			int high = 0xD800 | (biasedValue >> 10);
+			int low  = 0xDC00 | (biasedValue & 0x3FF);
+			encoding(stream, high);
+			encoding(stream, low);
+			return true;
+		}
+
+		void EncodeToUtf16LE(std::ostream& stream, int ch)
+		{
+			if (!SplitUtf16HighChar(stream, &EncodeToUtf16LE, ch))
+			{
+				stream << Byte(ch & 0xFF) << Byte(ch >> 8);
+			}
+		}
+
+		void EncodeToUtf16BE(std::ostream& stream, int ch)
+		{
+			if (!SplitUtf16HighChar(stream, &EncodeToUtf16BE, ch))
+			{
+				stream << Byte(ch >> 8) << Byte(ch & 0xFF);
+			}
+		}
+
+		void EncodeToUtf32LE(std::ostream& stream, int ch)
+		{
+			stream << Byte(ch & 0xFF) << Byte((ch >> 8) & 0xFF) 
+				<< Byte((ch >> 16) & 0xFF) << Byte((ch >> 24) & 0xFF);
+		}
+
+		void EncodeToUtf32BE(std::ostream& stream, int ch)
+		{
+			stream << Byte((ch >> 24) & 0xFF) << Byte((ch >> 16) & 0xFF)
+				<< Byte((ch >> 8) & 0xFF) << Byte(ch & 0xFF);
+		}
+
+		class EncodingTester
+		{
+		public:
+			EncodingTester(EncodingFn encoding, bool declareEncoding)
+			{
+				if (declareEncoding)
+				{
+					encoding(m_yaml, 0xFEFF);
+				}
+
+				AddEntry(encoding, 0x0021, 0x007E); // Basic Latin
+				AddEntry(encoding, 0x00A1, 0x00FF); // Latin-1 Supplement
+				AddEntry(encoding, 0x0660, 0x06FF); // Arabic (largest contiguous block)
+
+				// CJK unified ideographs (multiple lines)
+				AddEntry(encoding, 0x4E00, 0x4EFF);
+				AddEntry(encoding, 0x4F00, 0x4FFF);
+				AddEntry(encoding, 0x5000, 0x51FF); // 512 character line
+				AddEntry(encoding, 0x5200, 0x54FF); // 768 character line
+				AddEntry(encoding, 0x5500, 0x58FF); // 1024 character line
+
+				AddEntry(encoding, 0x103A0, 0x103C3); // Old Persian
+
+				m_yaml.seekg(0, std::ios::beg);
+			}
+
+			std::istream& stream() {return m_yaml;}
+			const std::vector<std::string>& entries() {return m_entries;}
+
+		private:
+			std::stringstream m_yaml;
+			std::vector<std::string> m_entries;
+
+			void AddEntry(EncodingFn encoding, int startCh, int endCh)
+			{
+				encoding(m_yaml, '-');
+				encoding(m_yaml, ' ');
+				encoding(m_yaml, '|');
+				encoding(m_yaml, '\n');
+				encoding(m_yaml, ' ');
+				encoding(m_yaml, ' ');
+
+				std::stringstream entry;
+				for (int ch = startCh; ch <= endCh; ++ch)
+				{
+					encoding(m_yaml, ch);
+					EncodeToUtf8(entry, ch);
+				}
+				encoding(m_yaml, '\n');
+
+				m_entries.push_back(entry.str());
+			}
+		};
+
+		void RunEncodingTest(EncodingFn encoding, bool declareEncoding, const std::string& name, bool& passed)
+		{
+			EncodingTester tester(encoding, declareEncoding);
+			std::string error;
+			bool ok = true;
+			try {
+				YAML::Parser parser(tester.stream());
+				YAML::Node doc;
+				parser.GetNextDocument(doc);
+
+				YAML::Iterator itNode = doc.begin();
+				std::vector<std::string>::const_iterator itEntry = tester.entries().begin();
+				for (; (itNode != doc.end()) && (itEntry != tester.entries().end()); ++itNode, ++itEntry)
+				{
+					std::string stScalarValue;
+					if (!itNode->GetScalar(stScalarValue) && (stScalarValue == *itEntry))
+					{
+						break;
+					}
+				}
+
+				if ((itNode != doc.end()) || (itEntry != tester.entries().end()))
+				{
+					ok = false;
+				}
+			} catch(const YAML::Exception& e) {
+				ok = false;
+				error = e.msg;
+			}
+			if(ok) {
+				std::cout << "Parser test passed: " << name << "\n";
+			} else {
+				passed = false;
+				std::cout << "Parser test failed: " << name << "\n";
+				if(error != "")
+					std::cout << "Caught exception: " << error << "\n";
+			}
+		}
+	}
+
+	bool RunParserTests()
+	{
+		bool passed = true;
+		RunScalarParserTest(&Parser::SimpleScalar, "simple scalar", passed);
+		RunScalarParserTest(&Parser::MultiLineScalar, "multi-line scalar", passed);
+		RunScalarParserTest(&Parser::LiteralScalar, "literal scalar", passed);
+		RunScalarParserTest(&Parser::FoldedScalar, "folded scalar", passed);
+		RunScalarParserTest(&Parser::ChompedFoldedScalar, "chomped folded scalar", passed);
+		RunScalarParserTest(&Parser::ChompedLiteralScalar, "chomped literal scalar", passed);
+		RunScalarParserTest(&Parser::FoldedScalarWithIndent, "folded scalar with indent", passed);
+		RunScalarParserTest(&Parser::ColonScalar, "colon scalar", passed);
+		RunScalarParserTest(&Parser::QuotedScalar, "quoted scalar", passed);
+		RunScalarParserTest(&Parser::CommaScalar, "comma scalar", passed);
+		RunScalarParserTest(&Parser::DashScalar, "dash scalar", passed);
+		RunScalarParserTest(&Parser::URLScalar, "url scalar", passed);
+
+		RunParserTest(&Parser::SimpleSeq, "simple seq", passed);
+		RunParserTest(&Parser::SimpleMap, "simple map", passed);
+		RunParserTest(&Parser::FlowSeq, "flow seq", passed);
+		RunParserTest(&Parser::FlowMap, "flow map", passed);
+		RunParserTest(&Parser::FlowMapWithOmittedKey, "flow map with omitted key", passed);
+		RunParserTest(&Parser::FlowMapWithOmittedValue, "flow map with omitted value", passed);
+		RunParserTest(&Parser::FlowMapWithSoloEntry, "flow map with solo entry", passed);
+		RunParserTest(&Parser::FlowMapEndingWithSoloEntry, "flow map ending with solo entry", passed);
+		RunParserTest(&Parser::QuotedSimpleKeys, "quoted simple keys", passed);
+		RunParserTest(&Parser::CompressedMapAndSeq, "compressed map and seq", passed);
+		RunParserTest(&Parser::NullBlockSeqEntry, "null block seq entry", passed);
+		RunParserTest(&Parser::NullBlockMapKey, "null block map key", passed);
+		RunParserTest(&Parser::NullBlockMapValue, "null block map value", passed);
+		RunParserTest(&Parser::SimpleAlias, "simple alias", passed);
+		RunParserTest(&Parser::AliasWithNull, "alias with null", passed);
+		RunParserTest(&Parser::AnchorInSimpleKey, "anchor in simple key", passed);
+		RunParserTest(&Parser::AliasAsSimpleKey, "alias as simple key", passed);
+		RunParserTest(&Parser::ExplicitDoc, "explicit doc", passed);
+		RunParserTest(&Parser::MultipleDocs, "multiple docs", passed);
+		RunParserTest(&Parser::ExplicitEndDoc, "explicit end doc", passed);
+		RunParserTest(&Parser::MultipleDocsWithSomeExplicitIndicators, "multiple docs with some explicit indicators", passed);
+		
+		RunEncodingTest(&EncodeToUtf8, false, "UTF-8, no BOM", passed);
+		RunEncodingTest(&EncodeToUtf8, true, "UTF-8 with BOM", passed);
+		RunEncodingTest(&EncodeToUtf16LE, false, "UTF-16LE, no BOM", passed);
+		RunEncodingTest(&EncodeToUtf16LE, true, "UTF-16LE with BOM", passed);
+		RunEncodingTest(&EncodeToUtf16BE, false, "UTF-16BE, no BOM", passed);
+		RunEncodingTest(&EncodeToUtf16BE, true, "UTF-16BE with BOM", passed);
+		RunEncodingTest(&EncodeToUtf32LE, false, "UTF-32LE, no BOM", passed);
+		RunEncodingTest(&EncodeToUtf32LE, true, "UTF-32LE with BOM", passed);
+		RunEncodingTest(&EncodeToUtf32BE, false, "UTF-32BE, no BOM", passed);
+		RunEncodingTest(&EncodeToUtf32BE, true, "UTF-32BE with BOM", passed);
+		return passed;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Emitter tests
+	
+	namespace {
+		void RunEmitterTest(void (*test)(YAML::Emitter&, std::string&), const std::string& name, bool& passed) {
+			YAML::Emitter out;
+			std::string desiredOutput;
+			test(out, desiredOutput);
+			std::string output = out.c_str();
+
+			if(output == desiredOutput) {
+				std::cout << "Emitter test passed: " << name << "\n";
+			} else {
+				passed = false;
+				std::cout << "Emitter test failed: " << name << "\n";
+				std::cout << "Output:\n";
+				std::cout << output << "<<<\n";
+				std::cout << "Desired output:\n";
+				std::cout << desiredOutput << "<<<\n";				
+			}
+		}
+		
+		void RunEmitterErrorTest(void (*test)(YAML::Emitter&, std::string&), const std::string& name, bool& passed) {
+			YAML::Emitter out;
+			std::string desiredError;
+			test(out, desiredError);
+			std::string lastError = out.GetLastError();
+			if(!out.good() && lastError == desiredError) {
+				std::cout << "Emitter test passed: " << name << "\n";
+			} else {
+				passed = false;
+				std::cout << "Emitter test failed: " << name << "\n";
+				if(out.good())
+					std::cout << "No error detected\n";
+				else
+					std::cout << "Detected error: " << lastError << "\n";
+				std::cout << "Expected error: " << desiredError << "\n";
+			}
+		}
+	}
+	
+	bool RunEmitterTests()
+	{
+		bool passed = true;
+		RunEmitterTest(&Emitter::SimpleScalar, "simple scalar", passed);
+		RunEmitterTest(&Emitter::SimpleSeq, "simple seq", passed);
+		RunEmitterTest(&Emitter::SimpleFlowSeq, "simple flow seq", passed);
+		RunEmitterTest(&Emitter::EmptyFlowSeq, "empty flow seq", passed);
+		RunEmitterTest(&Emitter::NestedBlockSeq, "nested block seq", passed);
+		RunEmitterTest(&Emitter::NestedFlowSeq, "nested flow seq", passed);
+		RunEmitterTest(&Emitter::SimpleMap, "simple map", passed);
+		RunEmitterTest(&Emitter::SimpleFlowMap, "simple flow map", passed);
+		RunEmitterTest(&Emitter::MapAndList, "map and list", passed);
+		RunEmitterTest(&Emitter::ListAndMap, "list and map", passed);
+		RunEmitterTest(&Emitter::NestedBlockMap, "nested block map", passed);
+		RunEmitterTest(&Emitter::NestedFlowMap, "nested flow map", passed);
+		RunEmitterTest(&Emitter::MapListMix, "map list mix", passed);
+		RunEmitterTest(&Emitter::SimpleLongKey, "simple long key", passed);
+		RunEmitterTest(&Emitter::SingleLongKey, "single long key", passed);
+		RunEmitterTest(&Emitter::ComplexLongKey, "complex long key", passed);
+		RunEmitterTest(&Emitter::AutoLongKey, "auto long key", passed);
+		RunEmitterTest(&Emitter::ScalarFormat, "scalar format", passed);
+		RunEmitterTest(&Emitter::AutoLongKeyScalar, "auto long key scalar", passed);
+		RunEmitterTest(&Emitter::LongKeyFlowMap, "long key flow map", passed);
+		RunEmitterTest(&Emitter::BlockMapAsKey, "block map as key", passed);
+		RunEmitterTest(&Emitter::AliasAndAnchor, "alias and anchor", passed);
+		RunEmitterTest(&Emitter::AliasAndAnchorWithNull, "alias and anchor with null", passed);
+		RunEmitterTest(&Emitter::ComplexDoc, "complex doc", passed);
+		RunEmitterTest(&Emitter::STLContainers, "STL containers", passed);
+		RunEmitterTest(&Emitter::SimpleComment, "simple comment", passed);
+		RunEmitterTest(&Emitter::MultiLineComment, "multi-line comment", passed);
+		RunEmitterTest(&Emitter::ComplexComments, "complex comments", passed);
+		RunEmitterTest(&Emitter::Indentation, "indentation", passed);
+		RunEmitterTest(&Emitter::SimpleGlobalSettings, "simple global settings", passed);
+		RunEmitterTest(&Emitter::ComplexGlobalSettings, "complex global settings", passed);
+		RunEmitterTest(&Emitter::Null, "null", passed);
+		
+		RunEmitterErrorTest(&Emitter::ExtraEndSeq, "extra EndSeq", passed);
+		RunEmitterErrorTest(&Emitter::ExtraEndMap, "extra EndMap", passed);
+		RunEmitterErrorTest(&Emitter::BadSingleQuoted, "bad single quoted string", passed);
+		RunEmitterErrorTest(&Emitter::InvalidAnchor, "invalid anchor", passed);
+		RunEmitterErrorTest(&Emitter::InvalidAlias, "invalid alias", passed);
+		RunEmitterErrorTest(&Emitter::MissingKey, "missing key", passed);
+		RunEmitterErrorTest(&Emitter::MissingValue, "missing value", passed);
+		RunEmitterErrorTest(&Emitter::UnexpectedKey, "unexpected key", passed);
+		RunEmitterErrorTest(&Emitter::UnexpectedValue, "unexpected value", passed);
+		return passed;
+	}
+	
+}

yaml-reader/tests.h

@@ -0,0 +1,103 @@
+#pragma once
+
+#ifndef TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#include <string>
+
+namespace YAML { class Emitter; }
+
+namespace Test {
+	void RunAll();
+	
+	bool RunParserTests();
+	bool RunEmitterTests();
+
+	namespace Parser {
+		// scalar tests
+		void SimpleScalar(std::string& inputScalar, std::string& desiredOutput);
+		void MultiLineScalar(std::string& inputScalar, std::string& desiredOutput);
+		void LiteralScalar(std::string& inputScalar, std::string& desiredOutput);
+		void FoldedScalar(std::string& inputScalar, std::string& desiredOutput);
+		void ChompedFoldedScalar(std::string& inputScalar, std::string& desiredOutput);
+		void ChompedLiteralScalar(std::string& inputScalar, std::string& desiredOutput);
+		void FoldedScalarWithIndent(std::string& inputScalar, std::string& desiredOutput);
+		void ColonScalar(std::string& inputScalar, std::string& desiredOutput);
+		void QuotedScalar(std::string& inputScalar, std::string& desiredOutput);
+		void CommaScalar(std::string& inputScalar, std::string& desiredOutput);
+		void DashScalar(std::string& inputScalar, std::string& desiredOutput);
+		void URLScalar(std::string& inputScalar, std::string& desiredOutput);
+
+		// misc tests
+		bool SimpleSeq();
+		bool SimpleMap();
+		bool FlowSeq();
+		bool FlowMap();
+		bool FlowMapWithOmittedKey();
+		bool FlowMapWithOmittedValue();
+		bool FlowMapWithSoloEntry();
+		bool FlowMapEndingWithSoloEntry();
+		bool QuotedSimpleKeys();
+		bool CompressedMapAndSeq();
+		bool NullBlockSeqEntry();
+		bool NullBlockMapKey();
+		bool NullBlockMapValue();
+		bool SimpleAlias();
+		bool AliasWithNull();
+		bool AnchorInSimpleKey();
+		bool AliasAsSimpleKey();
+		bool ExplicitDoc();
+		bool MultipleDocs();
+		bool ExplicitEndDoc();
+		bool MultipleDocsWithSomeExplicitIndicators();
+	}
+	
+	namespace Emitter {
+		// correct emitting
+		void SimpleScalar(YAML::Emitter& out, std::string& desiredOutput);
+		void SimpleSeq(YAML::Emitter& out, std::string& desiredOutput);
+		void SimpleFlowSeq(YAML::Emitter& ouptut, std::string& desiredOutput);
+		void EmptyFlowSeq(YAML::Emitter& out, std::string& desiredOutput);
+		void NestedBlockSeq(YAML::Emitter& out, std::string& desiredOutput);
+		void NestedFlowSeq(YAML::Emitter& out, std::string& desiredOutput);
+		void SimpleMap(YAML::Emitter& out, std::string& desiredOutput);
+		void SimpleFlowMap(YAML::Emitter& out, std::string& desiredOutput);
+		void MapAndList(YAML::Emitter& out, std::string& desiredOutput);
+		void ListAndMap(YAML::Emitter& out, std::string& desiredOutput);
+		void NestedBlockMap(YAML::Emitter& out, std::string& desiredOutput);
+		void NestedFlowMap(YAML::Emitter& out, std::string& desiredOutput);
+		void MapListMix(YAML::Emitter& out, std::string& desiredOutput);
+		void SimpleLongKey(YAML::Emitter& out, std::string& desiredOutput);
+		void SingleLongKey(YAML::Emitter& out, std::string& desiredOutput);
+		void ComplexLongKey(YAML::Emitter& out, std::string& desiredOutput);
+		void AutoLongKey(YAML::Emitter& out, std::string& desiredOutput);
+		void ScalarFormat(YAML::Emitter& out, std::string& desiredOutput);
+		void AutoLongKeyScalar(YAML::Emitter& out, std::string& desiredOutput);
+		void LongKeyFlowMap(YAML::Emitter& out, std::string& desiredOutput);
+		void BlockMapAsKey(YAML::Emitter& out, std::string& desiredOutput);
+		void AliasAndAnchor(YAML::Emitter& out, std::string& desiredOutput);
+		void AliasAndAnchorWithNull(YAML::Emitter& out, std::string& desiredOutput);
+		void ComplexDoc(YAML::Emitter& out, std::string& desiredOutput);
+		void STLContainers(YAML::Emitter& out, std::string& desiredOutput);
+		void SimpleComment(YAML::Emitter& out, std::string& desiredOutput);
+		void MultiLineComment(YAML::Emitter& out, std::string& desiredOutput);
+		void ComplexComments(YAML::Emitter& out, std::string& desiredOutput);
+		void Indentation(YAML::Emitter& out, std::string& desiredOutput);
+		void SimpleGlobalSettings(YAML::Emitter& out, std::string& desiredOutput);
+		void ComplexGlobalSettings(YAML::Emitter& out, std::string& desiredOutput);
+		void Null(YAML::Emitter& out, std::string& desiredOutput);
+
+		// incorrect emitting
+		void ExtraEndSeq(YAML::Emitter& out, std::string& desiredError);
+		void ExtraEndMap(YAML::Emitter& out, std::string& desiredError);
+		void BadSingleQuoted(YAML::Emitter& out, std::string& desiredError);
+		void InvalidAnchor(YAML::Emitter& out, std::string& desiredError);
+		void InvalidAlias(YAML::Emitter& out, std::string& desiredError);
+		void MissingKey(YAML::Emitter& out, std::string& desiredError);
+		void MissingValue(YAML::Emitter& out, std::string& desiredError);
+		void UnexpectedKey(YAML::Emitter& out, std::string& desiredError);
+		void UnexpectedValue(YAML::Emitter& out, std::string& desiredError);
+	}
+}
+
+#endif // TESTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

yaml-reader/tests/aliased.yaml

@@ -0,0 +1,4 @@
+--- &list
+- This document contains a recursive list.
+- *list
+...

yamlcpp.sln

@@ -1,36 +1,27 @@
 
 Microsoft Visual Studio Solution File, Format Version 10.00
 # Visual Studio 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "yaml-reader", "yaml-reader.vcproj", "{E8CC0D8A-D784-4A6B-B78B-ACEA13F9FB0B}"
+	ProjectSection(ProjectDependencies) = postProject
+		{3104AB4E-CD31-4F47-95E9-0E8D9374E15D} = {3104AB4E-CD31-4F47-95E9-0E8D9374E15D}
+	EndProjectSection
+EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "yamlcpp", "yamlcpp.vcproj", "{3104AB4E-CD31-4F47-95E9-0E8D9374E15D}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "test", "test.vcproj", "{D1108F40-6ADF-467E-A95A-236C39A515C5}"
-	ProjectSection(ProjectDependencies) = postProject
-		{3104AB4E-CD31-4F47-95E9-0E8D9374E15D} = {3104AB4E-CD31-4F47-95E9-0E8D9374E15D}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "parse", "parse.vcproj", "{CD007B57-7812-4930-A5E2-6E5E56338814}"
-	ProjectSection(ProjectDependencies) = postProject
-		{3104AB4E-CD31-4F47-95E9-0E8D9374E15D} = {3104AB4E-CD31-4F47-95E9-0E8D9374E15D}
-	EndProjectSection
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
 		Release|Win32 = Release|Win32
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E8CC0D8A-D784-4A6B-B78B-ACEA13F9FB0B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E8CC0D8A-D784-4A6B-B78B-ACEA13F9FB0B}.Debug|Win32.Build.0 = Debug|Win32
+		{E8CC0D8A-D784-4A6B-B78B-ACEA13F9FB0B}.Release|Win32.ActiveCfg = Release|Win32
+		{E8CC0D8A-D784-4A6B-B78B-ACEA13F9FB0B}.Release|Win32.Build.0 = Release|Win32
 		{3104AB4E-CD31-4F47-95E9-0E8D9374E15D}.Debug|Win32.ActiveCfg = Debug|Win32
 		{3104AB4E-CD31-4F47-95E9-0E8D9374E15D}.Debug|Win32.Build.0 = Debug|Win32
 		{3104AB4E-CD31-4F47-95E9-0E8D9374E15D}.Release|Win32.ActiveCfg = Release|Win32
 		{3104AB4E-CD31-4F47-95E9-0E8D9374E15D}.Release|Win32.Build.0 = Release|Win32
-		{D1108F40-6ADF-467E-A95A-236C39A515C5}.Debug|Win32.ActiveCfg = Debug|Win32
-		{D1108F40-6ADF-467E-A95A-236C39A515C5}.Debug|Win32.Build.0 = Debug|Win32
-		{D1108F40-6ADF-467E-A95A-236C39A515C5}.Release|Win32.ActiveCfg = Release|Win32
-		{D1108F40-6ADF-467E-A95A-236C39A515C5}.Release|Win32.Build.0 = Release|Win32
-		{CD007B57-7812-4930-A5E2-6E5E56338814}.Debug|Win32.ActiveCfg = Debug|Win32
-		{CD007B57-7812-4930-A5E2-6E5E56338814}.Debug|Win32.Build.0 = Debug|Win32
-		{CD007B57-7812-4930-A5E2-6E5E56338814}.Release|Win32.ActiveCfg = Release|Win32
-		{CD007B57-7812-4930-A5E2-6E5E56338814}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

yamlcpp.vcproj

@@ -40,7 +40,6 @@
 			/>
 			<Tool
 				Name="VCCLCompilerTool"
-				AdditionalOptions="/D_SCL_SECURE_NO_WARNINGS"
 				Optimization="0"
 				AdditionalIncludeDirectories="include"
 				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
@@ -50,7 +49,6 @@
 				UsePrecompiledHeader="0"
 				WarningLevel="4"
 				DebugInformationFormat="3"
-				DisableSpecificWarnings="4127;4355"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -106,7 +104,6 @@
 			/>
 			<Tool
 				Name="VCCLCompilerTool"
-				AdditionalOptions="/D_SCL_SECURE_NO_WARNINGS"
 				Optimization="2"
 				EnableIntrinsicFunctions="true"
 				AdditionalIncludeDirectories="include"
@@ -116,7 +113,6 @@
 				UsePrecompiledHeader="0"
 				WarningLevel="4"
 				DebugInformationFormat="3"
-				DisableSpecificWarnings="4127;4355"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -175,6 +171,10 @@
 					RelativePath=".\src\aliascontent.cpp"
 					>
 				</File>
+				<File
+					RelativePath=".\src\content.cpp"
+					>
+				</File>
 				<File
 					RelativePath=".\src\conversion.cpp"
 					>
@@ -191,10 +191,6 @@
 					RelativePath=".\src\node.cpp"
 					>
 				</File>
-				<File
-					RelativePath=".\src\null.cpp"
-					>
-				</File>
 				<File
 					RelativePath=".\src\scalar.cpp"
 					>
@@ -203,10 +199,6 @@
 					RelativePath=".\src\sequence.cpp"
 					>
 				</File>
-				<File
-					RelativePath=".\src\tag.cpp"
-					>
-				</File>
 			</Filter>
 			<Filter
 				Name="Scanner"
@@ -227,10 +219,6 @@
 					RelativePath=".\src\scanscalar.cpp"
 					>
 				</File>
-				<File
-					RelativePath=".\src\scantag.cpp"
-					>
-				</File>
 				<File
 					RelativePath=".\src\scantoken.cpp"
 					>
@@ -345,10 +333,6 @@
 					RelativePath=".\src\sequence.h"
 					>
 				</File>
-				<File
-					RelativePath=".\src\tag.h"
-					>
-				</File>
 			</Filter>
 			<Filter
 				Name="Scanner"
@@ -373,10 +357,6 @@
 					RelativePath=".\src\scanscalar.h"
 					>
 				</File>
-				<File
-					RelativePath=".\src\scantag.h"
-					>
-				</File>
 				<File
 					RelativePath=".\src\stream.h"
 					>