Added overloads for parsing stl maps and vectors

CMakeLists.txt

@@ -10,16 +10,23 @@ if(IPHONE)
 endif(IPHONE)
 
 if(CMAKE_COMPILER_IS_GNUCC)
-  set(CMAKE_CXX_FLAGS "-O2 -Wall -pedantic -Wextra")
+  set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -pedantic -Wno-long-long ${CMAKE_CXX_FLAGS}")
 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 "0")
+set(YAML_CPP_VERSION_PATCH "4")
 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)
@@ -36,9 +43,9 @@ set(_INSTALL_DESTINATIONS
 	ARCHIVE DESTINATION lib${LIB_SUFFIX}
 )
 #
-file(GLOB public_headers include/*.h)
-file(GLOB private_headers src/*.h)
-file(GLOB sources src/*.cpp)
+file(GLOB public_headers include/[a-z]*.h)
+file(GLOB private_headers src/[a-z]*.h)
+file(GLOB sources src/[a-z]*.cpp)
 
 include_directories(${YAML_CPP_SOURCE_DIR}/include)
 add_library(yaml-cpp
@@ -64,5 +71,7 @@ if(UNIX)
 	install(FILES ${PC_FILE} DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
 endif(UNIX)
 
-add_subdirectory (yaml-reader)
-add_subdirectory (util)
+if(YAML_CPP_BUILD_TOOLS)
+	add_subdirectory (test)
+	add_subdirectory (util)
+endif(YAML_CPP_BUILD_TOOLS)

include/conversion.h

@@ -5,6 +5,7 @@
 
 
 #include "null.h"
+#include "traits.h"
 #include <string>
 #include <sstream>
 
@@ -18,26 +19,13 @@ namespace YAML
 	bool Convert(const std::string& input, bool& output);
 	bool Convert(const std::string& input, _Null& output);
 	
-#define YAML_MAKE_STREAM_CONVERT(type) \
-	inline bool Convert(const std::string& input, type& output) { \
-		std::stringstream stream(input); \
-		stream >> output; \
-		return !stream.fail(); \
+	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;
 	}
-	
-	YAML_MAKE_STREAM_CONVERT(char)
-	YAML_MAKE_STREAM_CONVERT(unsigned char)
-	YAML_MAKE_STREAM_CONVERT(int)
-	YAML_MAKE_STREAM_CONVERT(unsigned int)
-	YAML_MAKE_STREAM_CONVERT(short)
-	YAML_MAKE_STREAM_CONVERT(unsigned short)
-	YAML_MAKE_STREAM_CONVERT(long)
-	YAML_MAKE_STREAM_CONVERT(unsigned long)
-	YAML_MAKE_STREAM_CONVERT(float)
-	YAML_MAKE_STREAM_CONVERT(double)
-	YAML_MAKE_STREAM_CONVERT(long double)
-	
-#undef YAML_MAKE_STREAM_CONVERT
 }
 
 #endif // CONVERSION_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/crt.h

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

include/emitter.h

@@ -9,6 +9,7 @@
 #include "null.h"
 #include <memory>
 #include <string>
+#include <sstream>
 
 namespace YAML
 {
@@ -29,6 +30,7 @@ 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);
@@ -44,16 +46,23 @@ 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 };
 		
@@ -74,18 +83,61 @@ namespace YAML
 		std::auto_ptr <EmitterState> m_pState;
 	};
 	
-	// overloads of insertion
 	template <typename T>
-	inline Emitter& operator << (Emitter& emitter, T v) {
-		return emitter.Write(v);
+	inline Emitter& Emitter::WriteIntegralType(T value)
+	{
+		if(!good())
+			return *this;
+		
+		std::stringstream str;
+		PreWriteIntegralType(str);
+		str << value;
+		PostWriteIntegralType(str);
+		return *this;
 	}
 
-	template <>
+	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); }
+
 	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,6 +11,10 @@ namespace YAML
 	enum EMITTER_MANIP {
 		// general manipulators
 		Auto,
+
+		// output character set
+		EmitNonAscii,
+		EscapeNonAscii,
 		
 		// string manipulators
 		// Auto, // duplicate
@@ -76,6 +80,16 @@ namespace YAML
 	inline _Anchor Anchor(const std::string content) {
 		return _Anchor(content);
 	}
+	
+	struct _Tag {
+		_Tag(const std::string& content_): content(content_), verbatim(true) {}
+		std::string content;
+		bool verbatim;
+	};
+	
+	inline _Tag VerbatimTag(const std::string& content) {
+		return _Tag(content);
+	}
 
 	struct _Comment {
 		_Comment(const std::string& content_): content(content_) {}

include/exceptions.h

@@ -5,6 +5,7 @@
 
 
 #include "mark.h"
+#include "traits.h"
 #include <exception>
 #include <string>
 #include <sstream>
@@ -17,7 +18,12 @@ 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";
@@ -57,10 +63,27 @@ 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 {
@@ -102,22 +125,23 @@ namespace YAML
 
 	class KeyNotFound: public RepresentationException {
 	public:
-		KeyNotFound(const Mark& mark_)
-			: RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND) {}
+		template <typename T>
+		KeyNotFound(const Mark& mark_, const T& key_)
+			: RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {}
 	};
-
+	
 	template <typename T>
 	class TypedKeyNotFound: public KeyNotFound {
 	public:
 		TypedKeyNotFound(const Mark& mark_, const T& key_)
-			: KeyNotFound(mark_), key(key_) {}
-		~TypedKeyNotFound() throw() {}
+			: KeyNotFound(mark_, key_), key(key_) {}
+		virtual ~TypedKeyNotFound() throw() {}
 
 		T key;
 	};
 
 	template <typename T>
-	TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) {
+	inline TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) {
 		return TypedKeyNotFound <T> (mark, key);
 	}
 

include/node.h

@@ -9,7 +9,6 @@
 #include "iterator.h"
 #include "mark.h"
 #include "noncopyable.h"
-#include "parserstate.h"
 #include <iostream>
 #include <string>
 #include <vector>
@@ -21,6 +20,7 @@ namespace YAML
 	class Content;
 	class Scanner;
 	class Emitter;
+	struct ParserState;
 
 	enum CONTENT_TYPE { CT_NONE, CT_SCALAR, CT_SEQUENCE, CT_MAP };
 
@@ -32,7 +32,7 @@ namespace YAML
 
 		void Clear();
 		std::auto_ptr<Node> Clone() const;
-		void Parse(Scanner *pScanner, const ParserState& state);
+		void Parse(Scanner *pScanner, ParserState& state);
 
 		CONTENT_TYPE GetType() const;
 
@@ -75,6 +75,9 @@ 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);
@@ -99,10 +102,10 @@ namespace YAML
 		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);
+		void ParseHeader(Scanner *pScanner, ParserState& state);
+		void ParseTag(Scanner *pScanner, ParserState& state);
+		void ParseAnchor(Scanner *pScanner, ParserState& state);
+		void ParseAlias(Scanner *pScanner, ParserState& state);
 
 	private:
 		Mark m_mark;

include/nodeimpl.h

@@ -79,22 +79,22 @@ namespace YAML
 
 	template <typename T>
 	inline bool operator == (const T& value, const Node& node) {
-		return value == node.Read<T>();
+		return value == node.operator T();
 	}
 	
 	template <typename T>
 	inline bool operator == (const Node& node, const T& value) {
-		return value == node.Read<T>();
+		return value == node.operator T();
 	}
 	
 	template <typename T>
 	inline bool operator != (const T& value, const Node& node) {
-		return value != node.Read<T>();
+		return value != node.operator T();
 	}
 	
 	template <typename T>
 	inline bool operator != (const Node& node, const T& value) {
-		return value != node.Read<T>();
+		return value != node.operator T();
 	}
 
 	inline bool operator == (const char *value, const Node& node) {

include/nodereadimpl.h

@@ -6,7 +6,18 @@ namespace YAML
 	// (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;
 	
@@ -38,12 +49,13 @@ namespace YAML
 		struct flag { char c[2]; };
 		flag Convert(...);
 		
-		char (& operator,(flag, flag) )[1];
+		int operator,(flag, flag);
 		
 		template<typename T>
-		void operator,(flag, T const&);
+		char operator,(flag, T const&);
 		
-		char (& operator,(char(&)[1], flag) )[1];
+		char operator,(int, flag);
+		int operator,(char, flag);
 	}
 
 	template <typename T>
@@ -52,6 +64,7 @@ namespace YAML
 
 		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>

include/parser.h

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

include/parserstate.h

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

include/stlnode.h

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

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

parse.vcproj

@@ -2,9 +2,9 @@
 <VisualStudioProject
 	ProjectType="Visual C++"
 	Version="9.00"
-	Name="yaml-reader"
-	ProjectGUID="{E8CC0D8A-D784-4A6B-B78B-ACEA13F9FB0B}"
-	RootNamespace="yamlreader"
+	Name="parse"
+	ProjectGUID="{CD007B57-7812-4930-A5E2-6E5E56338814}"
+	RootNamespace="parse"
 	TargetFrameworkVersion="196613"
 	>
 	<Platforms>
@@ -39,13 +39,15 @@
 			/>
 			<Tool
 				Name="VCCLCompilerTool"
+				AdditionalOptions="/D_SCL_SECURE_NO_WARNINGS"
 				Optimization="0"
 				AdditionalIncludeDirectories="include"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"
 				WarningLevel="3"
-				DebugInformationFormat="3"
+				DebugInformationFormat="4"
+				DisableSpecificWarnings="4127;4355"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -110,13 +112,15 @@
 			/>
 			<Tool
 				Name="VCCLCompilerTool"
+				AdditionalOptions="/D_SCL_SECURE_NO_WARNINGS"
 				Optimization="2"
 				EnableIntrinsicFunctions="true"
 				AdditionalIncludeDirectories="include"
 				RuntimeLibrary="2"
 				EnableFunctionLevelLinking="true"
-				WarningLevel="4"
+				WarningLevel="3"
 				DebugInformationFormat="3"
+				DisableSpecificWarnings="4127;4355"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -168,19 +172,7 @@
 			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
 			>
 			<File
-				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"
+				RelativePath=".\util\parse.cpp"
 				>
 			</File>
 		</Filter>
@@ -189,10 +181,12 @@
 			Filter="h;hpp;hxx;hm;inl;inc;xsd"
 			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
 			>
-			<File
-				RelativePath=".\yaml-reader\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>

src/aliascontent.cpp

@@ -1,4 +1,3 @@
-#include "crt.h"
 #include "aliascontent.h"
 
 namespace YAML
@@ -13,7 +12,7 @@ namespace YAML
 		return 0; // TODO: how to clone an alias?
 	}
 
-	void AliasContent::Parse(Scanner * /*pScanner*/, const ParserState& /*state*/)
+	void AliasContent::Parse(Scanner * /*pScanner*/, ParserState& /*state*/)
 	{
 	}
 

src/aliascontent.h

@@ -15,7 +15,7 @@ namespace YAML
 		
 		virtual Content *Clone() const;
 
-		virtual void Parse(Scanner* pScanner, const ParserState& state);
+		virtual void Parse(Scanner* pScanner, ParserState& state);
 		virtual void Write(Emitter&) const;
 
 		virtual bool GetBegin(std::vector <Node *>::const_iterator&) const;

src/content.cpp

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