Merge branch 'master' into compact

10 files changed, 720 insertions, 52 deletions

diff --git a/Makefile b/Makefile
index 59f055b..ead0ddd 100644
--- a/Makefile
+++ b/Makefile
@@ -34,6 +34,11 @@ ifneq ($(findstring PUGIXML_NO_EXCEPTIONS,$(defines)),)
 	CXXFLAGS+=-fno-exceptions
 endif
 
+ifeq ($(findstring PUGIXML_NO_CXX11,$(defines)),)
+	# Can't use std=c++11 since Travis-CI has gcc 4.6.3
+	CXXFLAGS+=-std=c++0x
+endif
+
 OBJECTS=$(SOURCES:%=$(BUILD)/%.o)
 
 all: $(EXECUTABLE)
diff --git a/appveyor.yml b/appveyor.yml
index 33ed76b..641b835 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,4 +1,4 @@
-version: "{build}"
+version: "{branch}-{build}"
 
 build_script:
   - ps: .\tests\autotest-appveyor.ps1
\ No newline at end of file
diff --git a/docs/manual.adoc b/docs/manual.adoc
index 9d75ea1..0d31934 100644
--- a/docs/manual.adoc
+++ b/docs/manual.adoc
@@ -1668,7 +1668,9 @@ NOTE: You should use the usual bitwise arithmetics to manipulate the bitmask: to
 
 These flags control the resulting tree contents:
 
-* [[format_indent]]`format_indent` determines if all nodes should be indented with the indentation string (this is an additional parameter for all saving functions, and is `"\t"` by default). If this flag is on, before every node the indentation string is output several times, where the amount of indentation depends on the node's depth relative to the output subtree. This flag has no effect if <<format_raw,format_raw>> is enabled. This flag is *on* by default.
+* [[format_indent]]`format_indent` determines if all nodes should be indented with the indentation string (this is an additional parameter for all saving functions, and is `"\t"` by default). If this flag is on, the indentations string is printed several times before every node, where the amount of indentation depends on the node's depth relative to the output subtree. This flag has no effect if <<format_raw,format_raw>> is enabled. This flag is *on* by default.
+
+* [[format_indent_attributes]]`format_indent_attributes` determines if all attributes should be printed on a new line, indented with the indentation string according to the attribute's depth. This flag implies <<format_indent,format_indent>>. This flag has no effect if <<format_raw,format_raw>> is enabled. This flag is *off* by default.
 
 * [[format_raw]]`format_raw` switches between formatted and raw output. If this flag is on, the nodes are not indented in any way, and also no newlines that are not part of document text are printed. Raw mode can be used for serialization where the result is not intended to be read by humans; also it can be useful if the document was parsed with <<parse_ws_pcdata,parse_ws_pcdata>> flag, to preserve the original document formatting as much as possible. This flag is *off* by default.
 
@@ -2546,6 +2548,7 @@ enum +++<a href="#xpath_value_type">xpath_value_type</a>+++
 // Formatting options bit flags:
 const unsigned int +++<a href="#format_default">format_default</a>+++
 const unsigned int +++<a href="#format_indent">format_indent</a>+++
+const unsigned int +++<a href="#format_indent_attributes">format_indent_attributes</a>+++
 const unsigned int +++<a href="#format_no_declaration">format_no_declaration</a>+++
 const unsigned int +++<a href="#format_no_escapes">format_no_escapes</a>+++
 const unsigned int +++<a href="#format_raw">format_raw</a>+++
diff --git a/src/pugixml.cpp b/src/pugixml.cpp
index 5c39775..b2c13f5 100644
--- a/src/pugixml.cpp
+++ b/src/pugixml.cpp
@@ -2235,6 +2235,7 @@ PUGI__NS_BEGIN
 	
 		assert(begin + size == end);
 		(void)!end;
+		(void)!size;
 	}
 	
 #ifndef PUGIXML_NO_STL
@@ -3663,11 +3664,6 @@ PUGI__NS_BEGIN
 			PUGI__STATIC_ASSERT(bufcapacity >= 8);
 		}
 
-		~xml_buffered_writer()
-		{
-			flush();
-		}
-
 		size_t flush()
 		{
 			flush(buffer, bufsize);
@@ -4028,13 +4024,23 @@ PUGI__NS_BEGIN
 		}
 	}
 
-	PUGI__FN void node_output_attributes(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags)
+	PUGI__FN void node_output_attributes(xml_buffered_writer& writer, xml_node_struct* node, const char_t* indent, size_t indent_length, unsigned int flags, unsigned int depth)
 	{
 		const char_t* default_name = PUGIXML_TEXT(":anonymous");
 
 		for (xml_attribute_struct* a = node->first_attribute; a; a = a->next_attribute)
 		{
-			writer.write(' ');
+			if ((flags & (format_indent_attributes | format_raw)) == format_indent_attributes)
+			{
+				writer.write('\n');
+
+				text_output_indent(writer, indent, indent_length, depth + 1);
+			}
+			else
+			{
+				writer.write(' ');
+			}
+
 			writer.write_string(a->name ? a->name : default_name);
 			writer.write('=', '"');
 
@@ -4045,7 +4051,7 @@ PUGI__NS_BEGIN
 		}
 	}
 
-	PUGI__FN bool node_output_start(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags)
+	PUGI__FN bool node_output_start(xml_buffered_writer& writer, xml_node_struct* node, const char_t* indent, size_t indent_length, unsigned int flags, unsigned int depth)
 	{
 		const char_t* default_name = PUGIXML_TEXT(":anonymous");
 		const char_t* name = node->contents ? node->contents : default_name;
@@ -4054,7 +4060,7 @@ PUGI__NS_BEGIN
 		writer.write_string(name);
 
 		if (node->first_attribute)
-			node_output_attributes(writer, node, flags);
+			node_output_attributes(writer, node, indent, indent_length, flags, depth);
 
 		if (!node->first_child)
 		{
@@ -4114,7 +4120,7 @@ PUGI__NS_BEGIN
 			case node_declaration:
 				writer.write('<', '?');
 				writer.write_string(node->contents ? node->contents : default_name);
-				node_output_attributes(writer, node, flags);
+				node_output_attributes(writer, node, PUGIXML_TEXT(""), 0, flags | format_raw, 0);
 				writer.write('?', '>');
 				break;
 
@@ -4144,7 +4150,7 @@ PUGI__NS_BEGIN
 
 	PUGI__FN void node_output(xml_buffered_writer& writer, xml_node_struct* root, const char_t* indent, unsigned int flags, unsigned int depth)
 	{
-		size_t indent_length = ((flags & (format_indent | format_raw)) == format_indent) ? strlength(indent) : 0;
+		size_t indent_length = ((flags & (format_indent | format_indent_attributes)) && (flags & format_raw) == 0) ? strlength(indent) : 0;
 		unsigned int indent_flags = indent_indent;
 
 		xml_node_struct* node = root;
@@ -4172,7 +4178,7 @@ PUGI__NS_BEGIN
 				{
 					indent_flags = indent_newline | indent_indent;
 
-					if (node_output_start(writer, node, flags))
+					if (node_output_start(writer, node, indent, indent_length, flags, depth))
 					{
 						node = node->first_child;
 						depth++;
@@ -6145,6 +6151,8 @@ namespace pugi
 		impl::xml_buffered_writer buffered_writer(writer, encoding);
 
 		impl::node_output(buffered_writer, _root, indent, flags, depth);
+
+		buffered_writer.flush();
 	}
 
 #ifndef PUGIXML_NO_STL
@@ -6844,6 +6852,8 @@ namespace pugi
 		}
 
 		impl::node_output(buffered_writer, _root, indent, flags, 0);
+
+		buffered_writer.flush();
 	}
 
 #ifndef PUGIXML_NO_STL
@@ -8265,7 +8275,7 @@ PUGI__NS_BEGIN
 
 	struct xpath_variable_boolean: xpath_variable
 	{
-		xpath_variable_boolean(): value(false)
+		xpath_variable_boolean(): xpath_variable(xpath_type_boolean), value(false)
 		{
 		}
 
@@ -8275,7 +8285,7 @@ PUGI__NS_BEGIN
 
 	struct xpath_variable_number: xpath_variable
 	{
-		xpath_variable_number(): value(0)
+		xpath_variable_number(): xpath_variable(xpath_type_number), value(0)
 		{
 		}
 
@@ -8285,7 +8295,7 @@ PUGI__NS_BEGIN
 
 	struct xpath_variable_string: xpath_variable
 	{
-		xpath_variable_string(): value(0)
+		xpath_variable_string(): xpath_variable(xpath_type_string), value(0)
 		{
 		}
 
@@ -8300,6 +8310,10 @@ PUGI__NS_BEGIN
 
 	struct xpath_variable_node_set: xpath_variable
 	{
+		xpath_variable_node_set(): xpath_variable(xpath_type_node_set)
+		{
+		}
+
 		xpath_node_set value;
 		char_t name[1];
 	};
@@ -8393,6 +8407,28 @@ PUGI__NS_BEGIN
 		}
 	}
 
+	PUGI__FN bool copy_xpath_variable(xpath_variable* lhs, const xpath_variable* rhs)
+	{
+		switch (rhs->type())
+		{
+		case xpath_type_node_set:
+			return lhs->set(static_cast<const xpath_variable_node_set*>(rhs)->value);
+
+		case xpath_type_number:
+			return lhs->set(static_cast<const xpath_variable_number*>(rhs)->value);
+
+		case xpath_type_string:
+			return lhs->set(static_cast<const xpath_variable_string*>(rhs)->value);
+
+		case xpath_type_boolean:
+			return lhs->set(static_cast<const xpath_variable_boolean*>(rhs)->value);
+
+		default:
+			assert(!"Invalid variable type");
+			return false;
+		}
+	}
+
 	PUGI__FN bool get_variable_scratch(char_t (&buffer)[32], xpath_variable_set* set, const char_t* begin, const char_t* end, xpath_variable** out_result)
 	{
 		size_t length = static_cast<size_t>(end - begin);
@@ -11664,7 +11700,7 @@ namespace pugi
 	}
 #endif
 
-	PUGI__FN void xpath_node_set::_assign(const_iterator begin_, const_iterator end_)
+	PUGI__FN void xpath_node_set::_assign(const_iterator begin_, const_iterator end_, type_t type_)
 	{
 		assert(begin_ <= end_);
 
@@ -11680,6 +11716,7 @@ namespace pugi
 
 			_begin = &_storage;
 			_end = &_storage + size_;
+			_type = type_;
 		}
 		else
 		{
@@ -11703,38 +11740,72 @@ namespace pugi
 			// finalize
 			_begin = storage;
 			_end = storage + size_;
+			_type = type_;
 		}
 	}
 
+#if __cplusplus >= 201103
+	PUGI__FN void xpath_node_set::_move(xpath_node_set& rhs)
+	{
+		_type = rhs._type;
+		_storage = rhs._storage;
+		_begin = (rhs._begin == &rhs._storage) ? &_storage : rhs._begin;
+		_end = _begin + (rhs._end - rhs._begin);
+
+		rhs._type = type_unsorted;
+		rhs._begin = &rhs._storage;
+		rhs._end = rhs._begin;
+	}
+#endif
+
 	PUGI__FN xpath_node_set::xpath_node_set(): _type(type_unsorted), _begin(&_storage), _end(&_storage)
 	{
 	}
 
-	PUGI__FN xpath_node_set::xpath_node_set(const_iterator begin_, const_iterator end_, type_t type_): _type(type_), _begin(&_storage), _end(&_storage)
+	PUGI__FN xpath_node_set::xpath_node_set(const_iterator begin_, const_iterator end_, type_t type_): _type(type_unsorted), _begin(&_storage), _end(&_storage)
 	{
-		_assign(begin_, end_);
+		_assign(begin_, end_, type_);
 	}
 
 	PUGI__FN xpath_node_set::~xpath_node_set()
 	{
-		if (_begin != &_storage) impl::xml_memory::deallocate(_begin);
+		if (_begin != &_storage)
+			impl::xml_memory::deallocate(_begin);
 	}
 		
-	PUGI__FN xpath_node_set::xpath_node_set(const xpath_node_set& ns): _type(ns._type), _begin(&_storage), _end(&_storage)
+	PUGI__FN xpath_node_set::xpath_node_set(const xpath_node_set& ns): _type(type_unsorted), _begin(&_storage), _end(&_storage)
 	{
-		_assign(ns._begin, ns._end);
+		_assign(ns._begin, ns._end, ns._type);
 	}
 	
 	PUGI__FN xpath_node_set& xpath_node_set::operator=(const xpath_node_set& ns)
 	{
 		if (this == &ns) return *this;
-		
-		_type = ns._type;
-		_assign(ns._begin, ns._end);
+
+		_assign(ns._begin, ns._end, ns._type);
 
 		return *this;
 	}
 
+#if __cplusplus >= 201103
+	PUGI__FN xpath_node_set::xpath_node_set(xpath_node_set&& rhs): _type(type_unsorted), _begin(&_storage), _end(&_storage)
+	{
+		_move(rhs);
+	}
+
+	PUGI__FN xpath_node_set& xpath_node_set::operator=(xpath_node_set&& rhs)
+	{
+		if (this == &rhs) return *this;
+
+		if (_begin != &_storage)
+			impl::xml_memory::deallocate(_begin);
+
+		_move(rhs);
+
+		return *this;
+	}
+#endif
+
 	PUGI__FN xpath_node_set::type_t xpath_node_set::type() const
 	{
 		return _type;
@@ -11790,7 +11861,7 @@ namespace pugi
 		return error ? error : "No error";
 	}
 
-	PUGI__FN xpath_variable::xpath_variable(): _type(xpath_type_none), _next(0)
+	PUGI__FN xpath_variable::xpath_variable(xpath_value_type type_): _type(type_), _next(0)
 	{
 	}
 
@@ -11889,27 +11960,80 @@ namespace pugi
 
 	PUGI__FN xpath_variable_set::xpath_variable_set()
 	{
-		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i) _data[i] = 0;
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+			_data[i] = 0;
 	}
 
 	PUGI__FN xpath_variable_set::~xpath_variable_set()
 	{
 		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+			_destroy(_data[i]);
+	}
+
+	PUGI__FN xpath_variable_set::xpath_variable_set(const xpath_variable_set& rhs)
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+			_data[i] = 0;
+
+		_assign(rhs);
+	}
+
+	PUGI__FN xpath_variable_set& xpath_variable_set::operator=(const xpath_variable_set& rhs)
+	{
+		if (this == &rhs) return *this;
+
+		_assign(rhs);
+
+		return *this;
+	}
+
+#if __cplusplus >= 201103
+	PUGI__FN xpath_variable_set::xpath_variable_set(xpath_variable_set&& rhs)
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
 		{
-			xpath_variable* var = _data[i];
+			_data[i] = rhs._data[i];
+			rhs._data[i] = 0;
+		}
+	}
 
-			while (var)
-			{
-				xpath_variable* next = var->_next;
+	PUGI__FN xpath_variable_set& xpath_variable_set::operator=(xpath_variable_set&& rhs)
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+		{
+			_destroy(_data[i]);
 
-				impl::delete_xpath_variable(var->_type, var);
+			_data[i] = rhs._data[i];
+			rhs._data[i] = 0;
+		}
 
-				var = next;
-			}
+		return *this;
+	}
+#endif
+
+	PUGI__FN void xpath_variable_set::_assign(const xpath_variable_set& rhs)
+	{
+		xpath_variable_set temp;
+
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+			if (rhs._data[i] && !_clone(rhs._data[i], &temp._data[i]))
+				return;
+
+		_swap(temp);
+	}
+
+	PUGI__FN void xpath_variable_set::_swap(xpath_variable_set& rhs)
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+		{
+			xpath_variable* chain = _data[i];
+
+			_data[i] = rhs._data[i];
+			rhs._data[i] = chain;
 		}
 	}
 
-	PUGI__FN xpath_variable* xpath_variable_set::find(const char_t* name) const
+	PUGI__FN xpath_variable* xpath_variable_set::_find(const char_t* name) const
 	{
 		const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
 		size_t hash = impl::hash_string(name) % hash_size;
@@ -11922,6 +12046,45 @@ namespace pugi
 		return 0;
 	}
 
+	PUGI__FN bool xpath_variable_set::_clone(xpath_variable* var, xpath_variable** out_result)
+	{
+		xpath_variable* last = 0;
+
+		while (var)
+		{
+			// allocate storage for new variable
+			xpath_variable* nvar = impl::new_xpath_variable(var->_type, var->name());
+			if (!nvar) return false;
+
+			// link the variable to the result immediately to handle failures gracefully
+			if (last)
+				last->_next = nvar;
+			else
+				*out_result = nvar;
+
+			last = nvar;
+
+			// copy the value; this can fail due to out-of-memory conditions
+			if (!impl::copy_xpath_variable(nvar, var)) return false;
+
+			var = var->_next;
+		}
+
+		return true;
+	}
+
+	PUGI__FN void xpath_variable_set::_destroy(xpath_variable* var)
+	{
+		while (var)
+		{
+			xpath_variable* next = var->_next;
+
+			impl::delete_xpath_variable(var->_type, var);
+
+			var = next;
+		}
+	}
+
 	PUGI__FN xpath_variable* xpath_variable_set::add(const char_t* name, xpath_value_type type)
 	{
 		const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
@@ -11937,7 +12100,6 @@ namespace pugi
 
 		if (result)
 		{
-			result->_type = type;
 			result->_next = _data[hash];
 
 			_data[hash] = result;
@@ -11972,12 +12134,12 @@ namespace pugi
 
 	PUGI__FN xpath_variable* xpath_variable_set::get(const char_t* name)
 	{
-		return find(name);
+		return _find(name);
 	}
 
 	PUGI__FN const xpath_variable* xpath_variable_set::get(const char_t* name) const
 	{
-		return find(name);
+		return _find(name);
 	}
 
 	PUGI__FN xpath_query::xpath_query(const char_t* query, xpath_variable_set* variables): _impl(0)
@@ -12008,12 +12170,37 @@ namespace pugi
 		}
 	}
 
+	PUGI__FN xpath_query::xpath_query(): _impl(0)
+	{
+	}
+
 	PUGI__FN xpath_query::~xpath_query()
 	{
 		if (_impl)
 			impl::xpath_query_impl::destroy(static_cast<impl::xpath_query_impl*>(_impl));
 	}
 
+#if __cplusplus >= 201103
+	PUGI__FN xpath_query::xpath_query(xpath_query&& rhs)
+	{
+		_impl = rhs._impl;
+		rhs._impl = 0;
+	}
+
+	xpath_query& xpath_query::operator=(xpath_query&& rhs)
+	{
+		if (this == &rhs) return *this;
+
+		if (_impl)
+			impl::xpath_query_impl::destroy(static_cast<impl::xpath_query_impl*>(_impl));
+
+		_impl = rhs._impl;
+		rhs._impl = 0;
+
+		return *this;
+	}
+#endif
+
 	PUGI__FN xpath_value_type xpath_query::return_type() const
 	{
 		if (!_impl) return xpath_type_none;
diff --git a/src/pugixml.hpp b/src/pugixml.hpp
index d59f864..0f79fb7 100644
--- a/src/pugixml.hpp
+++ b/src/pugixml.hpp
@@ -65,7 +65,7 @@
 
 // If the platform is known to have long long support, enable long long functions
 #ifndef PUGIXML_HAS_LONG_LONG
-#	if defined(__cplusplus) && __cplusplus >= 201103
+#	if __cplusplus >= 201103
 #		define PUGIXML_HAS_LONG_LONG
 #	elif defined(_MSC_VER) && _MSC_VER >= 1400
 #		define PUGIXML_HAS_LONG_LONG
@@ -203,10 +203,13 @@ namespace pugi
 	// Open file using text mode in xml_document::save_file. This enables special character (i.e. new-line) conversions on some systems. This flag is off by default.
 	const unsigned int format_save_file_text = 0x20;
 
+	// Write every attribute on a new line with appropriate indentation. This flag is off by default.
+	const unsigned int format_indent_attributes = 0x40;
+
 	// The default set of formatting flags.
 	// Nodes are indented depending on their depth in DOM tree, a default declaration is output if document has none.
 	const unsigned int format_default = format_indent;
-		
+
 	// Forward declarations
 	struct xml_attribute_struct;
 	struct xml_node_struct;
@@ -1040,7 +1043,7 @@ namespace pugi
 		xpath_value_type _type;
 		xpath_variable* _next;
 
-		xpath_variable();
+		xpath_variable(xpath_value_type type);
 
 		// Non-copyable semantics
 		xpath_variable(const xpath_variable&);
@@ -1072,17 +1075,29 @@ namespace pugi
 	private:
 		xpath_variable* _data[64];
 
-		// Non-copyable semantics
-		xpath_variable_set(const xpath_variable_set&);
-		xpath_variable_set& operator=(const xpath_variable_set&);
+		void _assign(const xpath_variable_set& rhs);
+		void _swap(xpath_variable_set& rhs);
 
-		xpath_variable* find(const char_t* name) const;
+		xpath_variable* _find(const char_t* name) const;
+
+		static bool _clone(xpath_variable* var, xpath_variable** out_result);
+		static void _destroy(xpath_variable* var);
 
 	public:
 		// Default constructor/destructor
 		xpath_variable_set();
 		~xpath_variable_set();
 
+		// Copy constructor/assignment operator
+		xpath_variable_set(const xpath_variable_set& rhs);
+		xpath_variable_set& operator=(const xpath_variable_set& rhs);
+
+	#if __cplusplus >= 201103
+		// Move semantics support
+		xpath_variable_set(xpath_variable_set&& rhs);
+		xpath_variable_set& operator=(xpath_variable_set&& rhs);
+	#endif
+
 		// Add a new variable or get the existing one, if the types match
 		xpath_variable* add(const char_t* name, xpath_value_type type);
 
@@ -1115,9 +1130,18 @@ namespace pugi
 		// If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on compilation errors.
 		explicit xpath_query(const char_t* query, xpath_variable_set* variables = 0);
 
+		// Constructor
+		xpath_query();
+
 		// Destructor
 		~xpath_query();
 
+	#if __cplusplus >= 201103
+		// Move semantics support
+		xpath_query(xpath_query&& rhs);
+		xpath_query& operator=(xpath_query&& rhs);
+	#endif
+
 		// Get query expression return type
 		xpath_value_type return_type() const;
 		
@@ -1253,6 +1277,12 @@ namespace pugi
 		xpath_node_set(const xpath_node_set& ns);
 		xpath_node_set& operator=(const xpath_node_set& ns);
 
+	#if __cplusplus >= 201103
+		// Move semantics support
+		xpath_node_set(xpath_node_set&& rhs);
+		xpath_node_set& operator=(xpath_node_set&& rhs);
+	#endif
+
 		// Get collection type
 		type_t type() const;
 		
@@ -1283,7 +1313,8 @@ namespace pugi
 		xpath_node* _begin;
 		xpath_node* _end;
 
-		void _assign(const_iterator begin, const_iterator end);
+		void _assign(const_iterator begin, const_iterator end, type_t type);
+		void _move(xpath_node_set& rhs);
 	};
 #endif
 
diff --git a/tests/allocator.cpp b/tests/allocator.cpp
index 8ca0963..e1d99d5 100644
--- a/tests/allocator.cpp
+++ b/tests/allocator.cpp
@@ -2,6 +2,7 @@
 
 #include <string.h>
 #include <assert.h>
+#include <stdlib.h>
 
 // Low-level allocation functions
 #if defined(_WIN32) || defined(_WIN64)
@@ -80,7 +81,9 @@ namespace
 
 	void* allocate_page_aligned(size_t size)
 	{
-		return mmap(0, size + page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+		void* result = malloc(size + page_size);
+
+		return reinterpret_cast<void*>(align_to_page(reinterpret_cast<size_t>(result)));
 	}
 
 	void* allocate(size_t size)
@@ -111,8 +114,6 @@ namespace
 	}
 }
 #else
-#	include <stdlib.h>
-
 namespace
 {
 	void* allocate(size_t size)
diff --git a/tests/test_dom_traverse.cpp b/tests/test_dom_traverse.cpp
index 4423dbe..e4b8c44 100644
--- a/tests/test_dom_traverse.cpp
+++ b/tests/test_dom_traverse.cpp
@@ -1106,3 +1106,27 @@ TEST_XML(dom_unspecified_bool_coverage, "<node attr='value'>text</node>")
 	static_cast<void (*)(xpath_node***)>(qn)(0);
 #endif
 }
+
+#if __cplusplus >= 201103
+TEST_XML(dom_ranged_for, "<node attr1='1' attr2='2'><test>3</test><fake>5</fake><test>4</test></node>")
+{
+	int index = 1;
+
+	for (xml_node n: doc.children())
+	{
+		for (xml_attribute a: n.attributes())
+		{
+			CHECK(a.as_int() == index);
+			index++;
+		}
+
+		for (xml_node c: n.children(STR("test")))
+		{
+			CHECK(c.text().as_int() == index);
+			index++;
+		}
+	}
+
+	CHECK(index == 5);
+}
+#endif
diff --git a/tests/test_write.cpp b/tests/test_write.cpp
index af4acf4..df7b0b1 100644
--- a/tests/test_write.cpp
+++ b/tests/test_write.cpp
@@ -21,6 +21,31 @@ TEST_XML(write_indent, "<node attr='1'><child><sub>text</sub></child></node>")
 	CHECK_NODE_EX(doc, STR("<node attr=\"1\">\n\t<child>\n\t\t<sub>text</sub>\n\t</child>\n</node>\n"), STR("\t"), format_indent);
 }
 
+TEST_XML(write_indent_attributes, "<node attr='1' other='2'><child><sub>text</sub></child></node>")
+{
+	CHECK_NODE_EX(doc, STR("<node\n\tattr=\"1\"\n\tother=\"2\">\n\t<child>\n\t\t<sub>text</sub>\n\t</child>\n</node>\n"), STR("\t"), format_indent_attributes);
+}
+
+TEST_XML(write_indent_attributes_empty_element, "<node attr='1' other='2' />")
+{
+	CHECK_NODE_EX(doc, STR("<node\n\tattr=\"1\"\n\tother=\"2\" />\n"), STR("\t"), format_indent_attributes);
+}
+
+TEST_XML_FLAGS(write_indent_attributes_declaration, "<?xml version=\"1.0\" encoding=\"UTF-8\"?><node attr='1' other='2' />", parse_full)
+{
+	CHECK_NODE_EX(doc, STR("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<node\n\tattr=\"1\"\n\tother=\"2\" />\n"), STR("\t"), format_indent_attributes);
+}
+
+TEST_XML(write_indent_attributes_raw, "<node attr='1' other='2'><child><sub>text</sub></child></node>")
+{
+	CHECK_NODE_EX(doc, STR("<node attr=\"1\" other=\"2\"><child><sub>text</sub></child></node>"), STR("\t"), format_indent_attributes | format_raw);
+}
+
+TEST_XML(write_indent_attributes_empty_indent, "<node attr='1' other='2'><child><sub>text</sub></child></node>")
+{
+	CHECK_NODE_EX(doc, STR("<node\nattr=\"1\"\nother=\"2\">\n<child>\n<sub>text</sub>\n</child>\n</node>\n"), STR(""), format_indent_attributes);
+}
+
 TEST_XML(write_pcdata, "<node attr='1'><child><sub/>text</child></node>")
 {
 	CHECK_NODE_EX(doc, STR("<node attr=\"1\">\n\t<child>\n\t\t<sub />text</child>\n</node>\n"), STR("\t"), format_indent);
@@ -360,7 +385,7 @@ TEST(write_encoding_huge_invalid)
 TEST(write_unicode_escape)
 {
 	char s_utf8[] = "<\xE2\x82\xAC \xC2\xA2='\"\xF0\xA4\xAD\xA2&#x0a;\"'>&amp;\x14\xF0\xA4\xAD\xA2&lt;</\xE2\x82\xAC>";
-	
+
 	xml_document doc;
 	CHECK(doc.load_buffer(s_utf8, sizeof(s_utf8), parse_default, encoding_utf8));
 
diff --git a/tests/test_xpath_api.cpp b/tests/test_xpath_api.cpp
index df078a0..295bd95 100644
--- a/tests/test_xpath_api.cpp
+++ b/tests/test_xpath_api.cpp
@@ -7,6 +7,7 @@
 #include "helpers.hpp"
 
 #include <string>
+#include <vector>
 
 TEST_XML(xpath_api_select_nodes, "<node><head/><foo/><foo/><tail/></node>")
 {
@@ -381,15 +382,20 @@ TEST_XML(xpath_api_node_set_assign_out_of_memory_preserve, "<node><a/><b/></node
 {
 	xpath_node_set ns = doc.select_nodes(STR("node/*"));
 	CHECK(ns.size() == 2);
+	CHECK(ns.type() == xpath_node_set::type_sorted);
 
 	xpath_node_set nsall = doc.select_nodes(STR("//*"));
+	nsall.sort(true);
 	CHECK(nsall.size() == 3);
+	CHECK(nsall.type() == xpath_node_set::type_sorted_reverse);
 
 	test_runner::_memory_fail_threshold = 1;
 
 	CHECK_ALLOC_FAIL(ns = nsall);
 
-	CHECK(ns.size() == 2 && ns[0] == doc.child(STR("node")).child(STR("a")) && ns[1] == doc.child(STR("node")).child(STR("b")));
+	CHECK(ns.size() == 2);
+	CHECK(ns.type() == xpath_node_set::type_sorted);
+	CHECK(ns[0] == doc.child(STR("node")).child(STR("a")) && ns[1] == doc.child(STR("node")).child(STR("b")));
 }
 
 TEST_XML(xpath_api_deprecated_select_single_node, "<node><head/><foo id='1'/><foo/><tail/></node>")
@@ -402,4 +408,224 @@ TEST_XML(xpath_api_deprecated_select_single_node, "<node><head/><foo id='1'/><fo
 	CHECK(n1.node().attribute(STR("id")).as_int() == 1);
 	CHECK(n2.node().attribute(STR("id")).as_int() == 1);
 }
+
+#if __cplusplus >= 201103
+TEST_XML(xpath_api_nodeset_move_ctor, "<node><foo/><foo/><bar/></node>")
+{
+	xpath_node_set set = doc.select_nodes(STR("node/bar/preceding::*"));
+
+	CHECK(set.size() == 2);
+	CHECK(set.type() == xpath_node_set::type_sorted_reverse);
+
+	test_runner::_memory_fail_threshold = 1;
+
+	xpath_node_set move = std::move(set);
+
+	CHECK(set.size() == 0);
+	CHECK(set.type() == xpath_node_set::type_unsorted);
+
+	CHECK(move.size() == 2);
+	CHECK(move.type() == xpath_node_set::type_sorted_reverse);
+	CHECK(move[1] == doc.first_child().first_child());
+}
+
+
+TEST_XML(xpath_api_nodeset_move_ctor_single, "<node><foo/><foo/><bar/></node>")
+{
+	xpath_node_set set = doc.select_nodes(STR("node/bar"));
+
+	CHECK(set.size() == 1);
+	CHECK(set.type() == xpath_node_set::type_sorted);
+
+	test_runner::_memory_fail_threshold = 1;
+
+	xpath_node_set move = std::move(set);
+
+	CHECK(set.size() == 0);
+	CHECK(set.type() == xpath_node_set::type_unsorted);
+
+	CHECK(move.size() == 1);
+	CHECK(move.type() == xpath_node_set::type_sorted);
+	CHECK(move[0] == doc.first_child().last_child());
+}
+
+TEST(xpath_api_nodeset_move_ctor_empty)
+{
+	xpath_node_set set;
+	set.sort();
+
+	CHECK(set.size() == 0);
+	CHECK(set.type() == xpath_node_set::type_sorted);
+
+	test_runner::_memory_fail_threshold = 1;
+
+	xpath_node_set move = std::move(set);
+
+	CHECK(set.size() == 0);
+	CHECK(set.type() == xpath_node_set::type_unsorted);
+
+	CHECK(move.size() == 0);
+	CHECK(move.type() == xpath_node_set::type_sorted);
+}
+
+TEST_XML(xpath_api_nodeset_move_assign, "<node><foo/><foo/><bar/></node>")
+{
+	xpath_node_set set = doc.select_nodes(STR("node/bar/preceding::*"));
+
+	CHECK(set.size() == 2);
+	CHECK(set.type() == xpath_node_set::type_sorted_reverse);
+
+	test_runner::_memory_fail_threshold = 1;
+
+	xpath_node_set move;
+
+	CHECK(move.size() == 0);
+	CHECK(move.type() == xpath_node_set::type_unsorted);
+
+	move = std::move(set);
+
+	CHECK(set.size() == 0);
+	CHECK(set.type() == xpath_node_set::type_unsorted);
+
+	CHECK(move.size() == 2);
+	CHECK(move.type() == xpath_node_set::type_sorted_reverse);
+	CHECK(move[1] == doc.first_child().first_child());
+}
+
+TEST_XML(xpath_api_nodeset_move_assign_destroy, "<node><foo/><foo/><bar/></node>")
+{
+	xpath_node_set set = doc.select_nodes(STR("node/bar/preceding::*"));
+
+	CHECK(set.size() == 2);
+	CHECK(set.type() == xpath_node_set::type_sorted_reverse);
+
+	xpath_node_set all = doc.select_nodes(STR("//*"));
+
+	CHECK(all.size() == 4);
+
+	test_runner::_memory_fail_threshold = 1;
+
+	all = std::move(set);
+
+	CHECK(set.size() == 0);
+	CHECK(set.type() == xpath_node_set::type_unsorted);
+
+	CHECK(all.size() == 2);
+	CHECK(all.type() == xpath_node_set::type_sorted_reverse);
+	CHECK(all[1] == doc.first_child().first_child());
+}
+
+TEST_XML(xpath_api_nodeset_move_assign_single, "<node><foo/><foo/><bar/></node>")
+{
+	xpath_node_set set = doc.select_nodes(STR("node/bar"));
+
+	CHECK(set.size() == 1);
+	CHECK(set.type() == xpath_node_set::type_sorted);
+
+	test_runner::_memory_fail_threshold = 1;
+
+	xpath_node_set move;
+
+	CHECK(move.size() == 0);
+	CHECK(move.type() == xpath_node_set::type_unsorted);
+
+	move = std::move(set);
+
+	CHECK(set.size() == 0);
+	CHECK(set.type() == xpath_node_set::type_unsorted);
+
+	CHECK(move.size() == 1);
+	CHECK(move.type() == xpath_node_set::type_sorted);
+	CHECK(move[0] == doc.first_child().last_child());
+}
+
+TEST(xpath_api_nodeset_move_assign_empty)
+{
+	xpath_node_set set;
+	set.sort();
+
+	CHECK(set.size() == 0);
+	CHECK(set.type() == xpath_node_set::type_sorted);
+
+	test_runner::_memory_fail_threshold = 1;
+
+	xpath_node_set move;
+
+	CHECK(move.size() == 0);
+	CHECK(move.type() == xpath_node_set::type_unsorted);
+
+	move = std::move(set);
+
+	CHECK(set.size() == 0);
+	CHECK(set.type() == xpath_node_set::type_unsorted);
+
+	CHECK(move.size() == 0);
+	CHECK(move.type() == xpath_node_set::type_sorted);
+}
+
+TEST(xpath_api_query_move)
+{
+	xml_node c;
+
+	xpath_query q1(STR("true()"));
+	xpath_query q4(STR("true() and false()"));
+
+	test_runner::_memory_fail_threshold = 1;
+
+	CHECK(q1);
+	CHECK(q1.evaluate_boolean(c));
+
+	xpath_query q2 = std::move(q1);
+	CHECK(!q1);
+	CHECK(!q1.evaluate_boolean(c));
+	CHECK(q2);
+	CHECK(q2.evaluate_boolean(c));
+
+	xpath_query q3;
+	CHECK(!q3);
+	CHECK(!q3.evaluate_boolean(c));
+
+	q3 = std::move(q2);
+	CHECK(!q2);
+	CHECK(!q2.evaluate_boolean(c));
+	CHECK(q3);
+	CHECK(q3.evaluate_boolean(c));
+
+	CHECK(q4);
+	CHECK(!q4.evaluate_boolean(c));
+
+	q4 = std::move(q3);
+
+	CHECK(!q3);
+	CHECK(!q3.evaluate_boolean(c));
+	CHECK(q4);
+	CHECK(q4.evaluate_boolean(c));
+
+	q4 = std::move(q4);
+
+	CHECK(q4);
+	CHECK(q4.evaluate_boolean(c));
+}
+
+TEST(xpath_api_query_vector)
+{
+	std::vector<xpath_query> qv;
+
+	for (int i = 0; i < 10; ++i)
+	{
+		char_t expr[2];
+		expr[0] = '0' + char_t(i);
+		expr[1] = 0;
+
+		qv.push_back(xpath_query(expr));
+	}
+
+	double result = 0;
+
+	for (auto& q: qv)
+		result += q.evaluate_number(xml_node());
+
+	CHECK(result == 45);
+}
+#endif
 #endif
diff --git a/tests/test_xpath_variables.cpp b/tests/test_xpath_variables.cpp
index 0d33312..f72d6ff 100644
--- a/tests/test_xpath_variables.cpp
+++ b/tests/test_xpath_variables.cpp
@@ -413,4 +413,170 @@ TEST_XML(xpath_variables_count_sum, "<node><c1>12</c1><c2>23</c2><c3>34</c3></no
 

 	CHECK_XPATH_NUMBER_VAR(xml_node(), STR("sum($c12) * count($c) - sum($c3)"), &set, 71);

 }

+

+TEST_XML(xpath_variables_copy, "<node />")

+{

+	xpath_variable_set set1;

+	set1.set(STR("a"), true);

+	set1.set(STR("b"), 2.0);

+	set1.set(STR("c"), STR("string"));

+	set1.set(STR("d"), doc.select_nodes(STR("//*")));

+

+	CHECK_XPATH_STRING_VAR(xml_node(), STR("substring($c, count($d[$a]) + $b)"), &set1, STR("ring"));

+

+	xpath_variable_set set2 = set1;

+

+	CHECK_XPATH_STRING_VAR(xml_node(), STR("substring($c, count($d[$a]) + $b)"), &set2, STR("ring"));

+

+	xpath_variable_set set3;

+

+	CHECK(!set3.get(STR("a")));

+

+	set3 = set1;

+

+	CHECK_XPATH_STRING_VAR(xml_node(), STR("substring($c, count($d[$a]) + $b)"), &set2, STR("ring"));

+

+	set3 = set3;

+

+	CHECK_XPATH_STRING_VAR(xml_node(), STR("substring($c, count($d[$a]) + $b)"), &set2, STR("ring"));

+

+	set3 = xpath_variable_set();

+

+	CHECK(!set3.get(STR("a")));

+}

+

+TEST_XML(xpath_variables_copy_out_of_memory, "<node />")

+{

+	xpath_variable_set set1;

+	set1.set(STR("a"), true);

+	set1.set(STR("b"), 2.0);

+	set1.set(STR("c"), STR("string"));

+	set1.set(STR("d"), doc.select_nodes(STR("//*")));

+

+	xpath_variable_set set2 = set1;

+

+	test_runner::_memory_fail_threshold = 32768 + 75 * sizeof(void*);

+

+	CHECK_ALLOC_FAIL(xpath_variable_set set3 = set1);

+

+	xpath_variable_set set4;

+

+	CHECK_ALLOC_FAIL(set4 = set1);

+	CHECK(!set4.get(STR("a")) && !set4.get(STR("b")) && !set4.get(STR("c")) && !set4.get(STR("d")));

+

+	CHECK_ALLOC_FAIL(set2 = set1);

+

+	CHECK(set2.get(STR("a")) && set2.get(STR("b")) && set2.get(STR("c")) && set2.get(STR("d")));

+

+	CHECK(set2.get(STR("a"))->get_boolean() == true);

+	CHECK(set2.get(STR("b"))->get_number() == 2.0);

+	CHECK_STRING(set2.get(STR("c"))->get_string(), STR("string"));

+	CHECK(set2.get(STR("d"))->get_node_set().size() == 1);

+}

+

+#if __cplusplus >= 201103

+TEST_XML(xpath_variables_move, "<node />")

+{

+	xpath_variable_set set;

+	set.set(STR("a"), true);

+	set.set(STR("b"), 2.0);

+	set.set(STR("c"), STR("string"));

+	set.set(STR("d"), doc.select_nodes(STR("//*")));

+

+	xpath_variable_set copy = set;

+	copy.set(STR("e"), 42.0);

+

+	test_runner::_memory_fail_threshold = 1;

+

+	xpath_variable_set move1 = std::move(set);

+

+	CHECK(!set.get(STR("a")) && !set.get(STR("b")) && !set.get(STR("c")) && !set.get(STR("d")));

+	CHECK(move1.get(STR("a")) && move1.get(STR("b")) && move1.get(STR("c")) && move1.get(STR("d")));

+

+	CHECK(move1.get(STR("a"))->get_boolean() == true);

+	CHECK(move1.get(STR("b"))->get_number() == 2.0);

+	CHECK_STRING(move1.get(STR("c"))->get_string(), STR("string"));

+	CHECK(move1.get(STR("d"))->get_node_set().size() == 1);

+

+	xpath_variable_set move2;

+	move2 = std::move(move1);

+

+	CHECK(!move1.get(STR("a")) && !move1.get(STR("b")) && !move1.get(STR("c")) && !move1.get(STR("d")));

+	CHECK(move2.get(STR("a")) && move2.get(STR("b")) && move2.get(STR("c")) && move2.get(STR("d")));

+

+	CHECK(copy.get(STR("e")));

+

+	copy = std::move(move2);

+

+	CHECK(!move2.get(STR("a")) && !move2.get(STR("b")) && !move2.get(STR("c")) && !move2.get(STR("d")));

+	CHECK(copy.get(STR("a")) && copy.get(STR("b")) && copy.get(STR("c")) && copy.get(STR("d")));

+	CHECK(!copy.get(STR("e")));

+

+	CHECK(copy.get(STR("a"))->get_boolean() == true);

+	CHECK(copy.get(STR("b"))->get_number() == 2.0);

+	CHECK_STRING(copy.get(STR("c"))->get_string(), STR("string"));

+	CHECK(copy.get(STR("d"))->get_node_set().size() == 1);

+}

+#endif

+

+TEST(xpath_variables_copy_big)

+{

+	xpath_variable_set set;

+

+	for (int i = 0; i < 100; ++i)

+	{

+		char_t name[4];

+		name[0] = 'a';

+		name[1] = '0' + char_t(i / 10);

+		name[2] = '0' + char_t(i % 10);

+		name[3] = 0;

+

+		set.set(name, double(i));

+	}

+

+	xpath_variable_set copy = set;

+

+	for (int i = 0; i < 100; ++i)

+	{

+		char_t name[4];

+		name[0] = 'a';

+		name[1] = '0' + char_t(i / 10);

+		name[2] = '0' + char_t(i % 10);

+		name[3] = 0;

+

+		CHECK(copy.get(name) && copy.get(name)->get_number() == i);

+	}

+}

+

+TEST(xpath_variables_copy_big_out_of_memory)

+{

+	xpath_variable_set set;

+

+	for (int i = 0; i < 100; ++i)

+	{

+		char_t name[4];

+		name[0] = 'a';

+		name[1] = '0' + char_t(i / 10);

+		name[2] = '0' + char_t(i % 10);

+		name[3] = 0;

+

+		set.set(name, double(i));

+	}

+

+	test_runner::_memory_fail_threshold = 1;

+

+	xpath_variable_set copy;

+	CHECK_ALLOC_FAIL(copy = set);

+

+	for (int i = 0; i < 100; ++i)

+	{

+		char_t name[4];

+		name[0] = 'a';

+		name[1] = '0' + char_t(i / 10);

+		name[2] = '0' + char_t(i % 10);

+		name[3] = 0;

+

+		CHECK(!copy.get(name));

+	}

+}

 #endif