Whitespace-only change: set noexpandtab & retab!

git-svn-id: http://pugixml.googlecode.com/svn/trunk@896 99668b35-9821-0410-8761-19e4c4f06640

1 files changed, 911 insertions, 911 deletions

diff --git a/src/pugixml.cpp b/src/pugixml.cpp
index 80b8913..9530a4d 100644
--- a/src/pugixml.cpp
+++ b/src/pugixml.cpp
@@ -25,9 +25,9 @@
 #ifndef PUGIXML_NO_XPATH
 #	include <math.h>
 #	include <float.h>
-#   ifdef PUGIXML_NO_EXCEPTIONS
-#       include <setjmp.h>
-#   endif
+#	ifdef PUGIXML_NO_EXCEPTIONS
+#		include <setjmp.h>
+#	endif
 #endif
 
 #ifndef PUGIXML_NO_STL
@@ -40,20 +40,20 @@
 #include <new>
 
 #ifdef _MSC_VER
-#   pragma warning(push)
+#	pragma warning(push)
 #	pragma warning(disable: 4127) // conditional expression is constant
 #	pragma warning(disable: 4324) // structure was padded due to __declspec(align())
 #	pragma warning(disable: 4611) // interaction between '_setjmp' and C++ object destruction is non-portable
 #	pragma warning(disable: 4702) // unreachable code
 #	pragma warning(disable: 4996) // this function or variable may be unsafe
-#   pragma warning(disable: 4793) // function compiled as native: presence of '_setjmp' makes a function unmanaged
+#	pragma warning(disable: 4793) // function compiled as native: presence of '_setjmp' makes a function unmanaged
 #endif
 
 #ifdef __INTEL_COMPILER
 #	pragma warning(disable: 177) // function was declared but never referenced 
-#   pragma warning(disable: 279) // controlling expression is constant
+#	pragma warning(disable: 279) // controlling expression is constant
 #	pragma warning(disable: 1478 1786) // function was declared "deprecated"
-#   pragma warning(disable: 1684) // conversion from pointer to same-sized integral type
+#	pragma warning(disable: 1684) // conversion from pointer to same-sized integral type
 #endif
 
 #if defined(__BORLANDC__) && defined(PUGIXML_HEADER_ONLY)
@@ -61,13 +61,13 @@
 #endif
 
 #ifdef __BORLANDC__
-#   pragma option push
+#	pragma option push
 #	pragma warn -8008 // condition is always false
 #	pragma warn -8066 // unreachable code
 #endif
 
 #ifdef __SNC__
-#   pragma diag_push
+#	pragma diag_push
 #	pragma diag_suppress=178 // function was declared but never referenced
 #	pragma diag_suppress=237 // controlling expression is constant
 #endif
@@ -103,20 +103,20 @@ using std::memmove;
 #endif
 
 #ifdef PUGIXML_HEADER_ONLY
-#   define PUGI__NS_BEGIN namespace pugi { namespace impl {
-#   define PUGI__NS_END } }
-#   define PUGI__FN inline
-#   define PUGI__FN_NO_INLINE inline
+#	define PUGI__NS_BEGIN namespace pugi { namespace impl {
+#	define PUGI__NS_END } }
+#	define PUGI__FN inline
+#	define PUGI__FN_NO_INLINE inline
 #else
-#   if defined(_MSC_VER) && _MSC_VER < 1300 // MSVC6 seems to have an amusing bug with anonymous namespaces inside namespaces
-#      define PUGI__NS_BEGIN namespace pugi { namespace impl {
-#      define PUGI__NS_END } }
-#   else
-#      define PUGI__NS_BEGIN namespace pugi { namespace impl { namespace {
-#      define PUGI__NS_END } } }
-#   endif
-#   define PUGI__FN
-#   define PUGI__FN_NO_INLINE PUGI__NO_INLINE
+#	if defined(_MSC_VER) && _MSC_VER < 1300 // MSVC6 seems to have an amusing bug with anonymous namespaces inside namespaces
+#		define PUGI__NS_BEGIN namespace pugi { namespace impl {
+#		define PUGI__NS_END } }
+#	else
+#		define PUGI__NS_BEGIN namespace pugi { namespace impl { namespace {
+#		define PUGI__NS_END } } }
+#	endif
+#	define PUGI__FN
+#	define PUGI__FN_NO_INLINE PUGI__NO_INLINE
 #endif
 
 // uintptr_t
@@ -129,9 +129,9 @@ typedef size_t uintptr_t;
 #define _UINTPTR_T_DEFINED
 #	endif
 PUGI__NS_BEGIN
-    typedef unsigned __int8 uint8_t;
-    typedef unsigned __int16 uint16_t;
-    typedef unsigned __int32 uint32_t;
+	typedef unsigned __int8 uint8_t;
+	typedef unsigned __int16 uint16_t;
+	typedef unsigned __int32 uint32_t;
 PUGI__NS_END
 #endif
 
@@ -147,17 +147,17 @@ PUGI__NS_BEGIN
 		free(ptr);
 	}
 
-    template <typename T>
-    struct xml_memory_management_function_storage
-    {
-        static allocation_function allocate;
-        static deallocation_function deallocate;
-    };
+	template <typename T>
+	struct xml_memory_management_function_storage
+	{
+		static allocation_function allocate;
+		static deallocation_function deallocate;
+	};
 
-    template <typename T> allocation_function xml_memory_management_function_storage<T>::allocate = default_allocate;
-    template <typename T> deallocation_function xml_memory_management_function_storage<T>::deallocate = default_deallocate;
+	template <typename T> allocation_function xml_memory_management_function_storage<T>::allocate = default_allocate;
+	template <typename T> deallocation_function xml_memory_management_function_storage<T>::deallocate = default_deallocate;
 
-    typedef xml_memory_management_function_storage<int> xml_memory;
+	typedef xml_memory_management_function_storage<int> xml_memory;
 PUGI__NS_END
 
 // String utilities
@@ -235,12 +235,12 @@ PUGI__NS_END
 
 PUGI__NS_BEGIN
 	static const size_t xml_memory_page_size =
-    #ifdef PUGIXML_MEMORY_PAGE_SIZE
-        PUGIXML_MEMORY_PAGE_SIZE
-    #else
-        32768
-    #endif
-        ;
+	#ifdef PUGIXML_MEMORY_PAGE_SIZE
+		PUGIXML_MEMORY_PAGE_SIZE
+	#else
+		32768
+	#endif
+		;
 
 	static const uintptr_t xml_memory_page_alignment = 32;
 	static const uintptr_t xml_memory_page_pointer_mask = ~(xml_memory_page_alignment - 1);
@@ -391,15 +391,15 @@ PUGI__NS_BEGIN
 			assert(full_size < (1 << 16) || (page->busy_size == full_size && page_offset == 0));
 			header->full_size = static_cast<uint16_t>(full_size < (1 << 16) ? full_size : 0);
 
-            // round-trip through void* to avoid 'cast increases required alignment of target type' warning
-            // header is guaranteed a pointer-sized alignment, which should be enough for char_t
+			// round-trip through void* to avoid 'cast increases required alignment of target type' warning
+			// header is guaranteed a pointer-sized alignment, which should be enough for char_t
 			return static_cast<char_t*>(static_cast<void*>(header + 1));
 		}
 
 		void deallocate_string(char_t* string)
 		{
-            // this function casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
-            // we're guaranteed the proper (pointer-sized) alignment on the input string if it was allocated via allocate_string
+			// this function casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
+			// we're guaranteed the proper (pointer-sized) alignment on the input string if it was allocated via allocate_string
 
 			// get header
 			xml_memory_string_header* header = static_cast<xml_memory_string_header*>(static_cast<void*>(string)) - 1;
@@ -423,7 +423,7 @@ PUGI__NS_BEGIN
 		const size_t large_allocation_threshold = xml_memory_page_size / 4;
 
 		xml_memory_page* page = allocate_page(size <= large_allocation_threshold ? xml_memory_page_size : size);
-        out_page = page;
+		out_page = page;
 
 		if (!page) return 0;
 
@@ -815,7 +815,7 @@ PUGI__NS_BEGIN
 
 		static value_type high(value_type result, uint32_t ch)
 		{
-            (void)ch;
+			(void)ch;
 
 			*result = '?';
 
@@ -862,7 +862,7 @@ PUGI__NS_BEGIN
 					// process aligned single-byte (ascii) blocks
 					if ((reinterpret_cast<uintptr_t>(data) & 3) == 0)
 					{
-                        // round-trip through void* to silence 'cast increases required alignment of target type' warnings
+						// round-trip through void* to silence 'cast increases required alignment of target type' warnings
 						while (size >= 4 && (*static_cast<const uint32_t*>(static_cast<const void*>(data)) & 0x80808080) == 0)
 						{
 							result = Traits::low(result, data[0]);
@@ -978,27 +978,27 @@ PUGI__NS_BEGIN
 		static inline typename Traits::value_type decode_latin1_block(const uint8_t* data, size_t size, typename Traits::value_type result)
 		{
 			for (size_t i = 0; i < size; ++i)
-            {
-                result = Traits::low(result, data[i]);
-            }
+			{
+				result = Traits::low(result, data[i]);
+			}
 
 			return result;
 		}
 
 		static inline typename Traits::value_type decode_wchar_block_impl(const uint16_t* data, size_t size, typename Traits::value_type result)
-        {
-            return decode_utf16_block(data, size, result);
-        }
+		{
+			return decode_utf16_block(data, size, result);
+		}
 
 		static inline typename Traits::value_type decode_wchar_block_impl(const uint32_t* data, size_t size, typename Traits::value_type result)
-        {
-            return decode_utf32_block(data, size, result);
-        }
+		{
+			return decode_utf32_block(data, size, result);
+		}
 
 		static inline typename Traits::value_type decode_wchar_block(const wchar_t* data, size_t size, typename Traits::value_type result)
-        {
-            return decode_wchar_block_impl(reinterpret_cast<const wchar_selector<sizeof(wchar_t)>::type*>(data), size, result);
-        }
+		{
+			return decode_wchar_block_impl(reinterpret_cast<const wchar_selector<sizeof(wchar_t)>::type*>(data), size, result);
+		}
 	};
 
 	template <typename T> PUGI__FN void convert_utf_endian_swap(T* result, const T* data, size_t length)
@@ -1179,7 +1179,7 @@ PUGI__NS_BEGIN
 	PUGI__FN bool need_endian_swap_utf(xml_encoding le, xml_encoding re)
 	{
 		return (le == encoding_utf16_be && re == encoding_utf16_le) || (le == encoding_utf16_le && re == encoding_utf16_be) ||
-		       (le == encoding_utf32_be && re == encoding_utf32_le) || (le == encoding_utf32_le && re == encoding_utf32_be);
+			   (le == encoding_utf32_be && re == encoding_utf32_le) || (le == encoding_utf32_le && re == encoding_utf32_be);
 	}
 
 	PUGI__FN bool convert_buffer_endian_swap(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
@@ -1323,7 +1323,7 @@ PUGI__NS_BEGIN
 				convert_buffer_utf32(out_buffer, out_length, contents, size, opt_true());
 		}
 
-        // source encoding is latin1
+		// source encoding is latin1
 		if (encoding == encoding_latin1) return convert_buffer_latin1(out_buffer, out_length, contents, size);
 
 		assert(!"Invalid encoding");
@@ -1374,28 +1374,28 @@ PUGI__NS_BEGIN
 		return true;
 	}
 
-    PUGI__FN size_t get_latin1_7bit_prefix_length(const uint8_t* data, size_t size)
-    {
-        for (size_t i = 0; i < size; ++i)
-            if (data[i] > 127)
-                return i;
+	PUGI__FN size_t get_latin1_7bit_prefix_length(const uint8_t* data, size_t size)
+	{
+		for (size_t i = 0; i < size; ++i)
+			if (data[i] > 127)
+				return i;
 
-        return size;
-    }
+		return size;
+	}
 
 	PUGI__FN bool convert_buffer_latin1(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
 	{
 		const uint8_t* data = static_cast<const uint8_t*>(contents);
 
-        // get size of prefix that does not need utf8 conversion
-        size_t prefix_length = get_latin1_7bit_prefix_length(data, size);
-        assert(prefix_length <= size);
+		// get size of prefix that does not need utf8 conversion
+		size_t prefix_length = get_latin1_7bit_prefix_length(data, size);
+		assert(prefix_length <= size);
 
-        const uint8_t* postfix = data + prefix_length;
-        size_t postfix_length = size - prefix_length;
+		const uint8_t* postfix = data + prefix_length;
+		size_t postfix_length = size - prefix_length;
 
-        // if no conversion is needed, just return the original buffer
-        if (postfix_length == 0) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
+		// if no conversion is needed, just return the original buffer
+		if (postfix_length == 0) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
 
 		// first pass: get length in utf8 units
 		out_length = prefix_length + utf_decoder<utf8_counter>::decode_latin1_block(postfix, postfix_length, 0);
@@ -1405,7 +1405,7 @@ PUGI__NS_BEGIN
 		if (!out_buffer) return false;
 
 		// second pass: convert latin1 input to utf8
-        memcpy(out_buffer, data, prefix_length);
+		memcpy(out_buffer, data, prefix_length);
 
 		uint8_t* out_begin = reinterpret_cast<uint8_t*>(out_buffer);
 		uint8_t* out_end = utf_decoder<utf8_writer>::decode_latin1_block(postfix, postfix_length, out_begin + prefix_length);
@@ -1441,7 +1441,7 @@ PUGI__NS_BEGIN
 				convert_buffer_utf32(out_buffer, out_length, contents, size, opt_true());
 		}
 
-        // source encoding is latin1
+		// source encoding is latin1
 		if (encoding == encoding_latin1) return convert_buffer_latin1(out_buffer, out_length, contents, size, is_mutable);
 
 		assert(!"Invalid encoding");
@@ -1452,27 +1452,27 @@ PUGI__NS_BEGIN
 	PUGI__FN size_t as_utf8_begin(const wchar_t* str, size_t length)
 	{
 		// get length in utf8 characters
-        return utf_decoder<utf8_counter>::decode_wchar_block(str, length, 0);
-    }
-
-    PUGI__FN void as_utf8_end(char* buffer, size_t size, const wchar_t* str, size_t length)
-    {
-        // convert to utf8
-        uint8_t* begin = reinterpret_cast<uint8_t*>(buffer);
-        uint8_t* end = utf_decoder<utf8_writer>::decode_wchar_block(str, length, begin);
-    
-        assert(begin + size == end);
-        (void)!end;
+		return utf_decoder<utf8_counter>::decode_wchar_block(str, length, 0);
+	}
+
+	PUGI__FN void as_utf8_end(char* buffer, size_t size, const wchar_t* str, size_t length)
+	{
+		// convert to utf8
+		uint8_t* begin = reinterpret_cast<uint8_t*>(buffer);
+		uint8_t* end = utf_decoder<utf8_writer>::decode_wchar_block(str, length, begin);
+	
+		assert(begin + size == end);
+		(void)!end;
 
 		// zero-terminate
 		buffer[size] = 0;
 	}
-    
+	
 #ifndef PUGIXML_NO_STL
-    PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length)
-    {
+	PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length)
+	{
 		// first pass: get length in utf8 characters
-        size_t size = as_utf8_begin(str, length);
+		size_t size = as_utf8_begin(str, length);
 
 		// allocate resulting string
 		std::string result;
@@ -1481,8 +1481,8 @@ PUGI__NS_BEGIN
 		// second pass: convert to utf8
 		if (size > 0) as_utf8_end(&result[0], size, str, length);
 
-	  	return result;
-    }
+		return result;
+	}
 
 	PUGI__FN std::basic_string<wchar_t> as_wide_impl(const char* str, size_t size)
 	{
@@ -1744,8 +1744,8 @@ PUGI__NS_BEGIN
 				break;
 			}
 
-            default:
-                break;
+			default:
+				break;
 		}
 		
 		return stre;
@@ -2051,7 +2051,7 @@ PUGI__NS_BEGIN
 	{
 		xml_allocator alloc;
 		char_t* error_offset;
-        xml_parse_status error_status;
+		xml_parse_status error_status;
 		
 		// Parser utilities.
 		#define PUGI__SKIPWS()			{ while (PUGI__IS_CHARTYPE(*s, ct_space)) ++s; }
@@ -2119,7 +2119,7 @@ PUGI__NS_BEGIN
 				{
 					// nested ignore section
 					s = parse_doctype_ignore(s);
-                    if (!s) return s;
+					if (!s) return s;
 				}
 				else if (s[0] == ']' && s[1] == ']' && s[2] == '>')
 				{
@@ -2147,20 +2147,20 @@ PUGI__NS_BEGIN
 					{
 						// ignore
 						s = parse_doctype_ignore(s);
-                        if (!s) return s;
+						if (!s) return s;
 					}
 					else
 					{
 						// some control group
 						s = parse_doctype_group(s, endch, false);
-                        if (!s) return s;
+						if (!s) return s;
 					}
 				}
 				else if (s[0] == '<' || s[0] == '"' || s[0] == '\'')
 				{
 					// unknown tag (forbidden), or some primitive group
 					s = parse_doctype_primitive(s);
-                    if (!s) return s;
+					if (!s) return s;
 				}
 				else if (*s == '>')
 				{
@@ -2259,26 +2259,26 @@ PUGI__NS_BEGIN
 			{
 				s -= 2;
 
-                if (cursor->parent) PUGI__THROW_ERROR(status_bad_doctype, s);
+				if (cursor->parent) PUGI__THROW_ERROR(status_bad_doctype, s);
 
-                char_t* mark = s + 9;
+				char_t* mark = s + 9;
 
 				s = parse_doctype_group(s, endch, true);
-                if (!s) return s;
+				if (!s) return s;
 
-                if (PUGI__OPTSET(parse_doctype))
-                {
-                    while (PUGI__IS_CHARTYPE(*mark, ct_space)) ++mark;
+				if (PUGI__OPTSET(parse_doctype))
+				{
+					while (PUGI__IS_CHARTYPE(*mark, ct_space)) ++mark;
 
-                    PUGI__PUSHNODE(node_doctype);
+					PUGI__PUSHNODE(node_doctype);
 
-                    cursor->value = mark;
+					cursor->value = mark;
 
-                    assert((s[0] == 0 && endch == '>') || s[-1] == '>');
-                    s[*s == 0 ? 0 : -1] = 0;
+					assert((s[0] == 0 && endch == '>') || s[-1] == '>');
+					s[*s == 0 ? 0 : -1] = 0;
 
-                    PUGI__POPNODE();
-                }
+					PUGI__POPNODE();
+				}
 			}
 			else if (*s == 0 && endch == '-') PUGI__THROW_ERROR(status_bad_comment, s);
 			else if (*s == 0 && endch == '[') PUGI__THROW_ERROR(status_bad_cdata, s);
@@ -2412,8 +2412,8 @@ PUGI__NS_BEGIN
 						else if (PUGI__IS_CHARTYPE(ch, ct_space))
 						{
 						LOC_ATTRIBUTES:
-						    while (true)
-						    {
+							while (true)
+							{
 								PUGI__SKIPWS(); // Eat any whitespace.
 						
 								if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // <... #...
@@ -2545,7 +2545,7 @@ PUGI__NS_BEGIN
 					else if (*s == '?') // '<?...'
 					{
 						s = parse_question(s, cursor, optmsk, endch);
-                        if (!s) return s;
+						if (!s) return s;
 
 						assert(cursor);
 						if ((cursor->header & xml_memory_page_type_mask) + 1 == node_declaration) goto LOC_ATTRIBUTES;
@@ -2553,7 +2553,7 @@ PUGI__NS_BEGIN
 					else if (*s == '!') // '<!...'
 					{
 						s = parse_exclamation(s, cursor, optmsk, endch);
-                        if (!s) return s;
+						if (!s) return s;
 					}
 					else if (*s == 0 && endch == '?') PUGI__THROW_ERROR(status_bad_pi, s);
 					else PUGI__THROW_ERROR(status_unrecognized_tag, s);
@@ -2564,20 +2564,20 @@ PUGI__NS_BEGIN
 
 					PUGI__SKIPWS(); // Eat whitespace if no genuine PCDATA here.
 
-                    if (*s == '<')
-                    {
-                        // We skipped some whitespace characters because otherwise we would take the tag branch instead of PCDATA one
-                        assert(mark != s);
-
-                        if (!PUGI__OPTSET(parse_ws_pcdata | parse_ws_pcdata_single))
-                        {
-                            continue;
-                        }
-                        else if (PUGI__OPTSET(parse_ws_pcdata_single))
-                        {
-                            if (s[1] != '/' || cursor->first_child) continue;
-                        }
-                    }
+					if (*s == '<')
+					{
+						// We skipped some whitespace characters because otherwise we would take the tag branch instead of PCDATA one
+						assert(mark != s);
+
+						if (!PUGI__OPTSET(parse_ws_pcdata | parse_ws_pcdata_single))
+						{
+							continue;
+						}
+						else if (PUGI__OPTSET(parse_ws_pcdata_single))
+						{
+							if (s[1] != '/' || cursor->first_child) continue;
+						}
+					}
 
 					s = mark;
 							
@@ -2608,7 +2608,7 @@ PUGI__NS_BEGIN
 			// check that last tag is closed
 			if (cursor != xmldoc) PUGI__THROW_ERROR(status_end_element_mismatch, s);
 
-            return s;
+			return s;
 		}
 
 		static xml_parse_result parse(char_t* buffer, size_t length, xml_node_struct* root, unsigned int optmsk)
@@ -2629,7 +2629,7 @@ PUGI__NS_BEGIN
 			buffer[length - 1] = 0;
 			
 			// perform actual parsing
-            parser.parse(buffer, xmldoc, optmsk, endch);
+			parser.parse(buffer, xmldoc, optmsk, endch);
 
 			xml_parse_result result = make_parse_result(parser.error_status, parser.error_offset ? parser.error_offset - buffer : 0);
 			assert(result.offset >= 0 && static_cast<size_t>(result.offset) <= length);
@@ -2818,7 +2818,7 @@ PUGI__NS_BEGIN
 	public:
 		xml_buffered_writer(xml_writer& writer_, xml_encoding user_encoding): writer(writer_), bufsize(0), encoding(get_write_encoding(user_encoding))
 		{
-            PUGI__STATIC_ASSERT(bufcapacity >= 8);
+			PUGI__STATIC_ASSERT(bufcapacity >= 8);
 		}
 
 		~xml_buffered_writer()
@@ -2963,26 +2963,26 @@ PUGI__NS_BEGIN
 		// utf16 maximum expansion: x2 (-> utf32)
 		// utf32 maximum expansion: x1
 		enum
-        {
-            bufcapacitybytes =
-            #ifdef PUGIXML_MEMORY_OUTPUT_STACK
-                PUGIXML_MEMORY_OUTPUT_STACK
-            #else
-                10240
-            #endif
-            ,
-            bufcapacity = bufcapacitybytes / (sizeof(char_t) + 4)
-        };
+		{
+			bufcapacitybytes =
+			#ifdef PUGIXML_MEMORY_OUTPUT_STACK
+				PUGIXML_MEMORY_OUTPUT_STACK
+			#else
+				10240
+			#endif
+			,
+			bufcapacity = bufcapacitybytes / (sizeof(char_t) + 4)
+		};
 
 		char_t buffer[bufcapacity];
 
-        union
-        {
-            uint8_t data_u8[4 * bufcapacity];
-            uint16_t data_u16[2 * bufcapacity];
-            uint32_t data_u32[bufcapacity];
-            char_t data_char[bufcapacity];
-        } scratch;
+		union
+		{
+			uint8_t data_u8[4 * bufcapacity];
+			uint16_t data_u16[2 * bufcapacity];
+			uint32_t data_u32[bufcapacity];
+			char_t data_char[bufcapacity];
+		} scratch;
 
 		xml_writer& writer;
 		size_t bufsize;
@@ -3031,12 +3031,12 @@ PUGI__NS_BEGIN
 	}
 
 	PUGI__FN void text_output(xml_buffered_writer& writer, const char_t* s, chartypex_t type, unsigned int flags)
-    {
-        if (flags & format_no_escapes)
-            writer.write(s);
-        else
-            text_output_escaped(writer, s, type);
-    }
+	{
+		if (flags & format_no_escapes)
+			writer.write(s);
+		else
+			text_output_escaped(writer, s, type);
+	}
 
 	PUGI__FN void text_output_cdata(xml_buffered_writer& writer, const char_t* s)
 	{
@@ -3070,7 +3070,7 @@ PUGI__NS_BEGIN
 			writer.write(a.name()[0] ? a.name() : default_name);
 			writer.write('=', '"');
 
-            text_output(writer, a.value(), ctx_special_attr, flags);
+			text_output(writer, a.value(), ctx_special_attr, flags);
 
 			writer.write('"');
 		}
@@ -3123,10 +3123,10 @@ PUGI__NS_BEGIN
 			{
 				writer.write('>');
 
-                if (node.first_child().type() == node_pcdata)
-                    text_output(writer, node.first_child().value(), ctx_special_pcdata, flags);
-                else
-                    text_output_cdata(writer, node.first_child().value());
+				if (node.first_child().type() == node_pcdata)
+					text_output(writer, node.first_child().value(), ctx_special_pcdata, flags);
+				else
+					text_output_cdata(writer, node.first_child().value());
 
 				writer.write('<', '/');
 				writer.write(name);
@@ -3190,13 +3190,13 @@ PUGI__NS_BEGIN
 			writer.write('<', '!', 'D', 'O', 'C');
 			writer.write('T', 'Y', 'P', 'E');
 
-            if (node.value()[0])
-            {
-                writer.write(' ');
-                writer.write(node.value());
-            }
+			if (node.value()[0])
+			{
+				writer.write(' ');
+				writer.write(node.value());
+			}
 
-            writer.write('>');
+			writer.write('>');
 			if ((flags & format_raw) == 0) writer.write('\n');
 			break;
 
@@ -3256,7 +3256,7 @@ PUGI__NS_BEGIN
 		case node_pcdata:
 		case node_cdata:
 		case node_comment:
-        case node_doctype:
+		case node_doctype:
 			dest.set_value(source.value());
 			break;
 
@@ -3280,17 +3280,17 @@ PUGI__NS_BEGIN
 		}
 	}
 
-    inline bool is_text_node(xml_node_struct* node)
-    {
-        xml_node_type type = static_cast<xml_node_type>((node->header & impl::xml_memory_page_type_mask) + 1);
+	inline bool is_text_node(xml_node_struct* node)
+	{
+		xml_node_type type = static_cast<xml_node_type>((node->header & impl::xml_memory_page_type_mask) + 1);
 
-        return type == node_pcdata || type == node_cdata;
-    }
+		return type == node_pcdata || type == node_cdata;
+	}
 
-    // get value with conversion functions
+	// get value with conversion functions
 	PUGI__FN int get_value_int(const char_t* value, int def)
 	{
-        if (!value) return def;
+		if (!value) return def;
 
 	#ifdef PUGIXML_WCHAR_MODE
 		return static_cast<int>(wcstol(value, 0, 10));
@@ -3301,7 +3301,7 @@ PUGI__NS_BEGIN
 
 	PUGI__FN unsigned int get_value_uint(const char_t* value, unsigned int def)
 	{
-        if (!value) return def;
+		if (!value) return def;
 
 	#ifdef PUGIXML_WCHAR_MODE
 		return static_cast<unsigned int>(wcstoul(value, 0, 10));
@@ -3312,7 +3312,7 @@ PUGI__NS_BEGIN
 
 	PUGI__FN double get_value_double(const char_t* value, double def)
 	{
-        if (!value) return def;
+		if (!value) return def;
 
 	#ifdef PUGIXML_WCHAR_MODE
 		return wcstod(value, 0);
@@ -3323,7 +3323,7 @@ PUGI__NS_BEGIN
 
 	PUGI__FN float get_value_float(const char_t* value, float def)
 	{
-        if (!value) return def;
+		if (!value) return def;
 
 	#ifdef PUGIXML_WCHAR_MODE
 		return static_cast<float>(wcstod(value, 0));
@@ -3334,7 +3334,7 @@ PUGI__NS_BEGIN
 
 	PUGI__FN bool get_value_bool(const char_t* value, bool def)
 	{
-        if (!value) return def;
+		if (!value) return def;
 
 		// only look at first char
 		char_t first = *value;
@@ -3343,9 +3343,9 @@ PUGI__NS_BEGIN
 		return (first == '1' || first == 't' || first == 'T' || first == 'y' || first == 'Y');
 	}
 
-    // set value with conversion functions
+	// set value with conversion functions
 	PUGI__FN bool set_value_buffer(char_t*& dest, uintptr_t& header, uintptr_t header_mask, char (&buf)[128])
-    {
+	{
 	#ifdef PUGIXML_WCHAR_MODE
 		char_t wbuf[128];
 		impl::widen_ascii(wbuf, buf);
@@ -3354,22 +3354,22 @@ PUGI__NS_BEGIN
 	#else
 		return strcpy_insitu(dest, header, header_mask, buf);
 	#endif
-    }
+	}
 
 	PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, int value)
-    {
+	{
 		char buf[128];
 		sprintf(buf, "%d", value);
 	
-        return set_value_buffer(dest, header, header_mask, buf);
-    }
+		return set_value_buffer(dest, header, header_mask, buf);
+	}
 
 	PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, unsigned int value)
 	{
 		char buf[128];
 		sprintf(buf, "%u", value);
 
-        return set_value_buffer(dest, header, header_mask, buf);
+		return set_value_buffer(dest, header, header_mask, buf);
 	}
 
 	PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, double value)
@@ -3377,7 +3377,7 @@ PUGI__NS_BEGIN
 		char buf[128];
 		sprintf(buf, "%g", value);
 
-        return set_value_buffer(dest, header, header_mask, buf);
+		return set_value_buffer(dest, header, header_mask, buf);
 	}
 	
 	PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, bool value)
@@ -3462,89 +3462,89 @@ PUGI__NS_BEGIN
 	}
 
 #ifndef PUGIXML_NO_STL
-    template <typename T> struct xml_stream_chunk
-    {
-        static xml_stream_chunk* create()
-        {
-            void* memory = xml_memory::allocate(sizeof(xml_stream_chunk));
-            
-            return new (memory) xml_stream_chunk();
-        }
-
-        static void destroy(void* ptr)
-        {
-            xml_stream_chunk* chunk = static_cast<xml_stream_chunk*>(ptr);
-
-            // free chunk chain
-            while (chunk)
-            {
-                xml_stream_chunk* next = chunk->next;
-                xml_memory::deallocate(chunk);
-                chunk = next;
-            }
-        }
-
-        xml_stream_chunk(): next(0), size(0)
-        {
-        }
-
-        xml_stream_chunk* next;
-        size_t size;
-
-        T data[xml_memory_page_size / sizeof(T)];
-    };
+	template <typename T> struct xml_stream_chunk
+	{
+		static xml_stream_chunk* create()
+		{
+			void* memory = xml_memory::allocate(sizeof(xml_stream_chunk));
+			
+			return new (memory) xml_stream_chunk();
+		}
+
+		static void destroy(void* ptr)
+		{
+			xml_stream_chunk* chunk = static_cast<xml_stream_chunk*>(ptr);
+
+			// free chunk chain
+			while (chunk)
+			{
+				xml_stream_chunk* next = chunk->next;
+				xml_memory::deallocate(chunk);
+				chunk = next;
+			}
+		}
+
+		xml_stream_chunk(): next(0), size(0)
+		{
+		}
+
+		xml_stream_chunk* next;
+		size_t size;
+
+		T data[xml_memory_page_size / sizeof(T)];
+	};
 
 	template <typename T> PUGI__FN xml_parse_status load_stream_data_noseek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
-    {
-        buffer_holder chunks(0, xml_stream_chunk<T>::destroy);
+	{
+		buffer_holder chunks(0, xml_stream_chunk<T>::destroy);
 
-        // read file to a chunk list
-        size_t total = 0;
-        xml_stream_chunk<T>* last = 0;
+		// read file to a chunk list
+		size_t total = 0;
+		xml_stream_chunk<T>* last = 0;
 
-        while (!stream.eof())
-        {
-            // allocate new chunk
-            xml_stream_chunk<T>* chunk = xml_stream_chunk<T>::create();
-            if (!chunk) return status_out_of_memory;
+		while (!stream.eof())
+		{
+			// allocate new chunk
+			xml_stream_chunk<T>* chunk = xml_stream_chunk<T>::create();
+			if (!chunk) return status_out_of_memory;
 
-            // append chunk to list
-            if (last) last = last->next = chunk;
-            else chunks.data = last = chunk;
+			// append chunk to list
+			if (last) last = last->next = chunk;
+			else chunks.data = last = chunk;
 
-            // read data to chunk
-            stream.read(chunk->data, static_cast<std::streamsize>(sizeof(chunk->data) / sizeof(T)));
-            chunk->size = static_cast<size_t>(stream.gcount()) * sizeof(T);
+			// read data to chunk
+			stream.read(chunk->data, static_cast<std::streamsize>(sizeof(chunk->data) / sizeof(T)));
+			chunk->size = static_cast<size_t>(stream.gcount()) * sizeof(T);
 
-            // read may set failbit | eofbit in case gcount() is less than read length, so check for other I/O errors
-            if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
+			// read may set failbit | eofbit in case gcount() is less than read length, so check for other I/O errors
+			if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
 
-            // guard against huge files (chunk size is small enough to make this overflow check work)
-            if (total + chunk->size < total) return status_out_of_memory;
-            total += chunk->size;
-        }
+			// guard against huge files (chunk size is small enough to make this overflow check work)
+			if (total + chunk->size < total) return status_out_of_memory;
+			total += chunk->size;
+		}
 
-        // copy chunk list to a contiguous buffer
-        char* buffer = static_cast<char*>(xml_memory::allocate(total));
-        if (!buffer) return status_out_of_memory;
+		// copy chunk list to a contiguous buffer
+		char* buffer = static_cast<char*>(xml_memory::allocate(total));
+		if (!buffer) return status_out_of_memory;
 
-        char* write = buffer;
+		char* write = buffer;
 
-        for (xml_stream_chunk<T>* chunk = static_cast<xml_stream_chunk<T>*>(chunks.data); chunk; chunk = chunk->next)
-        {
-            assert(write + chunk->size <= buffer + total);
-            memcpy(write, chunk->data, chunk->size);
-            write += chunk->size;
-        }
+		for (xml_stream_chunk<T>* chunk = static_cast<xml_stream_chunk<T>*>(chunks.data); chunk; chunk = chunk->next)
+		{
+			assert(write + chunk->size <= buffer + total);
+			memcpy(write, chunk->data, chunk->size);
+			write += chunk->size;
+		}
 
-        assert(write == buffer + total);
+		assert(write == buffer + total);
 
-        // return buffer
-        *out_buffer = buffer;
-        *out_size = total;
+		// return buffer
+		*out_buffer = buffer;
+		*out_size = total;
 
-        return status_ok;
-    }
+		return status_ok;
+	}
 
 	template <typename T> PUGI__FN xml_parse_status load_stream_data_seek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
 	{
@@ -3568,29 +3568,29 @@ PUGI__NS_BEGIN
 		stream.read(static_cast<T*>(buffer.data), static_cast<std::streamsize>(read_length));
 
 		// read may set failbit | eofbit in case gcount() is less than read_length (i.e. line ending conversion), so check for other I/O errors
-        if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
+		if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
 
 		// return buffer
 		size_t actual_length = static_cast<size_t>(stream.gcount());
 		assert(actual_length <= read_length);
 
-        *out_buffer = buffer.release();
-        *out_size = actual_length * sizeof(T);
+		*out_buffer = buffer.release();
+		*out_size = actual_length * sizeof(T);
 
-        return status_ok;
+		return status_ok;
 	}
 
 	template <typename T> PUGI__FN xml_parse_result load_stream_impl(xml_document& doc, std::basic_istream<T>& stream, unsigned int options, xml_encoding encoding)
 	{
-        void* buffer = 0;
-        size_t size = 0;
+		void* buffer = 0;
+		size_t size = 0;
 
-        // load stream to memory (using seek-based implementation if possible, since it's faster and takes less memory)
-        xml_parse_status status = (stream.tellg() < 0) ? load_stream_data_noseek(stream, &buffer, &size) : load_stream_data_seek(stream, &buffer, &size);
-        if (status != status_ok) return make_parse_result(status);
+		// load stream to memory (using seek-based implementation if possible, since it's faster and takes less memory)
+		xml_parse_status status = (stream.tellg() < 0) ? load_stream_data_noseek(stream, &buffer, &size) : load_stream_data_seek(stream, &buffer, &size);
+		if (status != status_ok) return make_parse_result(status);
 
 		return doc.load_buffer_inplace_own(buffer, size, options, encoding);
-    }
+	}
 #endif
 
 #if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__) || (defined(__MINGW32__) && !defined(__STRICT_ANSI__))
@@ -3605,16 +3605,16 @@ PUGI__NS_BEGIN
 
 		// first pass: get length in utf8 characters
 		size_t length = wcslen(str);
-        size_t size = as_utf8_begin(str, length);
+		size_t size = as_utf8_begin(str, length);
 
 		// allocate resulting string
 		char* result = static_cast<char*>(xml_memory::allocate(size + 1));
 		if (!result) return 0;
 
 		// second pass: convert to utf8
-        as_utf8_end(result, size, str, length);
+		as_utf8_end(result, size, str, length);
 
-	  	return result;
+		return result;
 	}
 
 	PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
@@ -3644,7 +3644,7 @@ PUGI__NS_BEGIN
 		xml_writer_file writer(file);
 		doc.save(writer, indent, flags, encoding);
 
-        int result = ferror(file);
+		int result = ferror(file);
 
 		fclose(file);
 
@@ -3661,7 +3661,7 @@ namespace pugi
 	PUGI__FN void xml_writer_file::write(const void* data, size_t size)
 	{
 		size_t result = fwrite(data, 1, size, static_cast<FILE*>(file));
-        (void)!result; // unfortunately we can't do proper error handling here
+		(void)!result; // unfortunately we can't do proper error handling here
 	}
 
 #ifndef PUGIXML_NO_STL
@@ -3721,19 +3721,19 @@ namespace pugi
 	{
 	}
 
-    PUGI__FN static void unspecified_bool_xml_attribute(xml_attribute***)
-    {
-    }
+	PUGI__FN static void unspecified_bool_xml_attribute(xml_attribute***)
+	{
+	}
 
 	PUGI__FN xml_attribute::operator xml_attribute::unspecified_bool_type() const
 	{
-      	return _attr ? unspecified_bool_xml_attribute : 0;
-   	}
+		return _attr ? unspecified_bool_xml_attribute : 0;
+	}
 
-   	PUGI__FN bool xml_attribute::operator!() const
-   	{
-   		return !_attr;
-   	}
+	PUGI__FN bool xml_attribute::operator!() const
+	{
+		return !_attr;
+	}
 
 	PUGI__FN bool xml_attribute::operator==(const xml_attribute& r) const
 	{
@@ -3765,15 +3765,15 @@ namespace pugi
 		return (_attr >= r._attr);
 	}
 
-   	PUGI__FN xml_attribute xml_attribute::next_attribute() const
-   	{
-    	return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
-   	}
+	PUGI__FN xml_attribute xml_attribute::next_attribute() const
+	{
+		return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
+	}
 
-    PUGI__FN xml_attribute xml_attribute::previous_attribute() const
-    {
-    	return _attr && _attr->prev_attribute_c->next_attribute ? xml_attribute(_attr->prev_attribute_c) : xml_attribute();
-    }
+	PUGI__FN xml_attribute xml_attribute::previous_attribute() const
+	{
+		return _attr && _attr->prev_attribute_c->next_attribute ? xml_attribute(_attr->prev_attribute_c) : xml_attribute();
+	}
 
 	PUGI__FN const char_t* xml_attribute::as_string(const char_t* def) const
 	{
@@ -3782,27 +3782,27 @@ namespace pugi
 
 	PUGI__FN int xml_attribute::as_int(int def) const
 	{
-        return impl::get_value_int(_attr ? _attr->value : 0, def);
+		return impl::get_value_int(_attr ? _attr->value : 0, def);
 	}
 
 	PUGI__FN unsigned int xml_attribute::as_uint(unsigned int def) const
 	{
-        return impl::get_value_uint(_attr ? _attr->value : 0, def);
+		return impl::get_value_uint(_attr ? _attr->value : 0, def);
 	}
 
 	PUGI__FN double xml_attribute::as_double(double def) const
 	{
-        return impl::get_value_double(_attr ? _attr->value : 0, def);
+		return impl::get_value_double(_attr ? _attr->value : 0, def);
 	}
 
 	PUGI__FN float xml_attribute::as_float(float def) const
 	{
-        return impl::get_value_float(_attr ? _attr->value : 0, def);
+		return impl::get_value_float(_attr ? _attr->value : 0, def);
 	}
 
 	PUGI__FN bool xml_attribute::as_bool(bool def) const
 	{
-        return impl::get_value_bool(_attr ? _attr->value : 0, def);
+		return impl::get_value_bool(_attr ? _attr->value : 0, def);
 	}
 
 	PUGI__FN bool xml_attribute::empty() const
@@ -3820,14 +3820,14 @@ namespace pugi
 		return (_attr && _attr->value) ? _attr->value : PUGIXML_TEXT("");
 	}
 
-    PUGI__FN size_t xml_attribute::hash_value() const
-    {
-        return static_cast<size_t>(reinterpret_cast<uintptr_t>(_attr) / sizeof(xml_attribute_struct));
-    }
+	PUGI__FN size_t xml_attribute::hash_value() const
+	{
+		return static_cast<size_t>(reinterpret_cast<uintptr_t>(_attr) / sizeof(xml_attribute_struct));
+	}
 
 	PUGI__FN xml_attribute_struct* xml_attribute::internal_object() const
 	{
-        return _attr;
+		return _attr;
 	}
 
 	PUGI__FN xml_attribute& xml_attribute::operator=(const char_t* rhs)
@@ -3878,28 +3878,28 @@ namespace pugi
 	{
 		if (!_attr) return false;
 
-        return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
 	}
 
 	PUGI__FN bool xml_attribute::set_value(unsigned int rhs)
 	{
 		if (!_attr) return false;
 
-        return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
 	}
 
 	PUGI__FN bool xml_attribute::set_value(double rhs)
 	{
 		if (!_attr) return false;
 
-        return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
 	}
 	
 	PUGI__FN bool xml_attribute::set_value(bool rhs)
 	{
 		if (!_attr) return false;
 
-        return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
 	}
 
 #ifdef __BORLANDC__
@@ -3922,19 +3922,19 @@ namespace pugi
 	{
 	}
 	
-    PUGI__FN static void unspecified_bool_xml_node(xml_node***)
-    {
-    }
+	PUGI__FN static void unspecified_bool_xml_node(xml_node***)
+	{
+	}
 
 	PUGI__FN xml_node::operator xml_node::unspecified_bool_type() const
 	{
-      	return _root ? unspecified_bool_xml_node : 0;
-   	}
+		return _root ? unspecified_bool_xml_node : 0;
+	}
 
-   	PUGI__FN bool xml_node::operator!() const
-   	{
-   		return !_root;
-   	}
+	PUGI__FN bool xml_node::operator!() const
+	{
+		return !_root;
+	}
 
 	PUGI__FN xml_node::iterator xml_node::begin() const
 	{
@@ -3955,21 +3955,21 @@ namespace pugi
 	{
 		return attribute_iterator(0, _root);
 	}
-    
-    PUGI__FN xml_object_range<xml_node_iterator> xml_node::children() const
-    {
-        return xml_object_range<xml_node_iterator>(begin(), end());
-    }
+	
+	PUGI__FN xml_object_range<xml_node_iterator> xml_node::children() const
+	{
+		return xml_object_range<xml_node_iterator>(begin(), end());
+	}
 
-    PUGI__FN xml_object_range<xml_named_node_iterator> xml_node::children(const char_t* name_) const
-    {
-        return xml_object_range<xml_named_node_iterator>(xml_named_node_iterator(child(name_), name_), xml_named_node_iterator());
-    }
+	PUGI__FN xml_object_range<xml_named_node_iterator> xml_node::children(const char_t* name_) const
+	{
+		return xml_object_range<xml_named_node_iterator>(xml_named_node_iterator(child(name_), name_), xml_named_node_iterator());
+	}
 
-    PUGI__FN xml_object_range<xml_attribute_iterator> xml_node::attributes() const
-    {
-        return xml_object_range<xml_attribute_iterator>(attributes_begin(), attributes_end());
-    }
+	PUGI__FN xml_object_range<xml_attribute_iterator> xml_node::attributes() const
+	{
+		return xml_object_range<xml_attribute_iterator>(attributes_begin(), attributes_end());
+	}
 
 	PUGI__FN bool xml_node::operator==(const xml_node& r) const
 	{
@@ -4092,10 +4092,10 @@ namespace pugi
 		return xml_node(static_cast<impl::xml_document_struct*>(page->allocator));
 	}
 
-    PUGI__FN xml_text xml_node::text() const
-    {
-        return xml_text(_root);
-    }
+	PUGI__FN xml_text xml_node::text() const
+	{
+		return xml_text(_root);
+	}
 
 	PUGI__FN const char_t* xml_node::child_value() const
 	{
@@ -4155,7 +4155,7 @@ namespace pugi
 		case node_cdata:
 		case node_pcdata:
 		case node_comment:
-        case node_doctype:
+		case node_doctype:
 			return impl::strcpy_insitu(_root->value, _root->header, impl::xml_memory_page_value_allocated_mask, rhs);
 
 		default:
@@ -4182,18 +4182,18 @@ namespace pugi
 
 		a.set_name(name_);
 		
-        xml_attribute_struct* head = _root->first_attribute;
+		xml_attribute_struct* head = _root->first_attribute;
 
 		if (head)
-        {
-            a._attr->prev_attribute_c = head->prev_attribute_c;
-            head->prev_attribute_c = a._attr;
-        }
-        else
-            a._attr->prev_attribute_c = a._attr;
+		{
+			a._attr->prev_attribute_c = head->prev_attribute_c;
+			head->prev_attribute_c = a._attr;
+		}
+		else
+			a._attr->prev_attribute_c = a._attr;
 		
 		a._attr->next_attribute = head;
-        _root->first_attribute = a._attr;
+		_root->first_attribute = a._attr;
 				
 		return a;
 	}
@@ -4312,20 +4312,20 @@ namespace pugi
 		xml_node n(impl::allocate_node(impl::get_allocator(_root), type_));
 		if (!n) return xml_node();
 
-        n._root->parent = _root;
+		n._root->parent = _root;
 
-        xml_node_struct* head = _root->first_child;
+		xml_node_struct* head = _root->first_child;
 
 		if (head)
-        {
-            n._root->prev_sibling_c = head->prev_sibling_c;
-            head->prev_sibling_c = n._root;
-        }
-        else
-            n._root->prev_sibling_c = n._root;
+		{
+			n._root->prev_sibling_c = head->prev_sibling_c;
+			head->prev_sibling_c = n._root;
+		}
+		else
+			n._root->prev_sibling_c = n._root;
 		
 		n._root->next_sibling = head;
-        _root->first_child = n._root;
+		_root->first_child = n._root;
 				
 		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
 
@@ -4380,41 +4380,41 @@ namespace pugi
 		return n;
 	}
 
-    PUGI__FN xml_node xml_node::append_child(const char_t* name_)
-    {
-        xml_node result = append_child(node_element);
+	PUGI__FN xml_node xml_node::append_child(const char_t* name_)
+	{
+		xml_node result = append_child(node_element);
 
-        result.set_name(name_);
+		result.set_name(name_);
 
-        return result;
-    }
+		return result;
+	}
 
-    PUGI__FN xml_node xml_node::prepend_child(const char_t* name_)
-    {
-        xml_node result = prepend_child(node_element);
+	PUGI__FN xml_node xml_node::prepend_child(const char_t* name_)
+	{
+		xml_node result = prepend_child(node_element);
 
-        result.set_name(name_);
+		result.set_name(name_);
 
-        return result;
-    }
+		return result;
+	}
 
-    PUGI__FN xml_node xml_node::insert_child_after(const char_t* name_, const xml_node& node)
-    {
-        xml_node result = insert_child_after(node_element, node);
+	PUGI__FN xml_node xml_node::insert_child_after(const char_t* name_, const xml_node& node)
+	{
+		xml_node result = insert_child_after(node_element, node);
 
-        result.set_name(name_);
+		result.set_name(name_);
 
-        return result;
-    }
+		return result;
+	}
 
-    PUGI__FN xml_node xml_node::insert_child_before(const char_t* name_, const xml_node& node)
-    {
-        xml_node result = insert_child_before(node_element, node);
+	PUGI__FN xml_node xml_node::insert_child_before(const char_t* name_, const xml_node& node)
+	{
+		xml_node result = insert_child_before(node_element, node);
 
-        result.set_name(name_);
+		result.set_name(name_);
 
-        return result;
-    }
+		return result;
+	}
 
 	PUGI__FN xml_node xml_node::append_copy(const xml_node& proto)
 	{
@@ -4493,8 +4493,8 @@ namespace pugi
 		
 		if (n._root->prev_sibling_c->next_sibling) n._root->prev_sibling_c->next_sibling = n._root->next_sibling;
 		else _root->first_child = n._root->next_sibling;
-        
-        impl::destroy_node(n._root, impl::get_allocator(_root));
+		
+		impl::destroy_node(n._root, impl::get_allocator(_root));
 
 		return true;
 	}
@@ -4642,14 +4642,14 @@ namespace pugi
 		return walker.end(arg_end);
 	}
 
-    PUGI__FN size_t xml_node::hash_value() const
-    {
-        return static_cast<size_t>(reinterpret_cast<uintptr_t>(_root) / sizeof(xml_node_struct));
-    }
+	PUGI__FN size_t xml_node::hash_value() const
+	{
+		return static_cast<size_t>(reinterpret_cast<uintptr_t>(_root) / sizeof(xml_node_struct));
+	}
 
 	PUGI__FN xml_node_struct* xml_node::internal_object() const
 	{
-        return _root;
+		return _root;
 	}
 
 	PUGI__FN void xml_node::print(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
@@ -4720,170 +4720,170 @@ namespace pugi
 	}
 #endif
 
-    PUGI__FN xml_text::xml_text(xml_node_struct* root): _root(root)
-    {
-    }
+	PUGI__FN xml_text::xml_text(xml_node_struct* root): _root(root)
+	{
+	}
 
-    PUGI__FN xml_node_struct* xml_text::_data() const
-    {
-        if (!_root || impl::is_text_node(_root)) return _root;
+	PUGI__FN xml_node_struct* xml_text::_data() const
+	{
+		if (!_root || impl::is_text_node(_root)) return _root;
 
-        for (xml_node_struct* node = _root->first_child; node; node = node->next_sibling)
-            if (impl::is_text_node(node))
-                return node;
+		for (xml_node_struct* node = _root->first_child; node; node = node->next_sibling)
+			if (impl::is_text_node(node))
+				return node;
 
-        return 0;
-    }
+		return 0;
+	}
 
-    PUGI__FN xml_node_struct* xml_text::_data_new()
-    {
-        xml_node_struct* d = _data();
-        if (d) return d;
+	PUGI__FN xml_node_struct* xml_text::_data_new()
+	{
+		xml_node_struct* d = _data();
+		if (d) return d;
 
-        return xml_node(_root).append_child(node_pcdata).internal_object();
-    }
+		return xml_node(_root).append_child(node_pcdata).internal_object();
+	}
 
-    PUGI__FN xml_text::xml_text(): _root(0)
-    {
-    }
+	PUGI__FN xml_text::xml_text(): _root(0)
+	{
+	}
 
-    PUGI__FN static void unspecified_bool_xml_text(xml_text***)
-    {
-    }
+	PUGI__FN static void unspecified_bool_xml_text(xml_text***)
+	{
+	}
 
-    PUGI__FN xml_text::operator xml_text::unspecified_bool_type() const
-    {
-        return _data() ? unspecified_bool_xml_text : 0;
-    }
+	PUGI__FN xml_text::operator xml_text::unspecified_bool_type() const
+	{
+		return _data() ? unspecified_bool_xml_text : 0;
+	}
 
-    PUGI__FN bool xml_text::operator!() const
-    {
-        return !_data();
-    }
+	PUGI__FN bool xml_text::operator!() const
+	{
+		return !_data();
+	}
 
-    PUGI__FN bool xml_text::empty() const
-    {
-        return _data() == 0;
-    }
+	PUGI__FN bool xml_text::empty() const
+	{
+		return _data() == 0;
+	}
 
-    PUGI__FN const char_t* xml_text::get() const
-    {
-        xml_node_struct* d = _data();
+	PUGI__FN const char_t* xml_text::get() const
+	{
+		xml_node_struct* d = _data();
 
-        return (d && d->value) ? d->value : PUGIXML_TEXT("");
-    }
+		return (d && d->value) ? d->value : PUGIXML_TEXT("");
+	}
 
-    PUGI__FN const char_t* xml_text::as_string(const char_t* def) const
-    {
-        xml_node_struct* d = _data();
+	PUGI__FN const char_t* xml_text::as_string(const char_t* def) const
+	{
+		xml_node_struct* d = _data();
 
-        return (d && d->value) ? d->value : def;
-    }
+		return (d && d->value) ? d->value : def;
+	}
 
-    PUGI__FN int xml_text::as_int(int def) const
-    {
-        xml_node_struct* d = _data();
+	PUGI__FN int xml_text::as_int(int def) const
+	{
+		xml_node_struct* d = _data();
 
-        return impl::get_value_int(d ? d->value : 0, def);
-    }
+		return impl::get_value_int(d ? d->value : 0, def);
+	}
 
-    PUGI__FN unsigned int xml_text::as_uint(unsigned int def) const
-    {
-        xml_node_struct* d = _data();
+	PUGI__FN unsigned int xml_text::as_uint(unsigned int def) const
+	{
+		xml_node_struct* d = _data();
 
-        return impl::get_value_uint(d ? d->value : 0, def);
-    }
+		return impl::get_value_uint(d ? d->value : 0, def);
+	}
 
-    PUGI__FN double xml_text::as_double(double def) const
-    {
-        xml_node_struct* d = _data();
+	PUGI__FN double xml_text::as_double(double def) const
+	{
+		xml_node_struct* d = _data();
 
-        return impl::get_value_double(d ? d->value : 0, def);
-    }
+		return impl::get_value_double(d ? d->value : 0, def);
+	}
 
-    PUGI__FN float xml_text::as_float(float def) const
-    {
-        xml_node_struct* d = _data();
+	PUGI__FN float xml_text::as_float(float def) const
+	{
+		xml_node_struct* d = _data();
 
-        return impl::get_value_float(d ? d->value : 0, def);
-    }
+		return impl::get_value_float(d ? d->value : 0, def);
+	}
 
-    PUGI__FN bool xml_text::as_bool(bool def) const
-    {
-        xml_node_struct* d = _data();
+	PUGI__FN bool xml_text::as_bool(bool def) const
+	{
+		xml_node_struct* d = _data();
 
-        return impl::get_value_bool(d ? d->value : 0, def);
-    }
+		return impl::get_value_bool(d ? d->value : 0, def);
+	}
 
-    PUGI__FN bool xml_text::set(const char_t* rhs)
-    {
-        xml_node_struct* dn = _data_new();
+	PUGI__FN bool xml_text::set(const char_t* rhs)
+	{
+		xml_node_struct* dn = _data_new();
 
-        return dn ? impl::strcpy_insitu(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
-    }
+		return dn ? impl::strcpy_insitu(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
 
-    PUGI__FN bool xml_text::set(int rhs)
-    {
-        xml_node_struct* dn = _data_new();
+	PUGI__FN bool xml_text::set(int rhs)
+	{
+		xml_node_struct* dn = _data_new();
 
-        return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
-    }
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
 
-    PUGI__FN bool xml_text::set(unsigned int rhs)
-    {
-        xml_node_struct* dn = _data_new();
+	PUGI__FN bool xml_text::set(unsigned int rhs)
+	{
+		xml_node_struct* dn = _data_new();
 
-        return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
-    }
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
 
-    PUGI__FN bool xml_text::set(double rhs)
-    {
-        xml_node_struct* dn = _data_new();
+	PUGI__FN bool xml_text::set(double rhs)
+	{
+		xml_node_struct* dn = _data_new();
 
-        return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
-    }
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
 
-    PUGI__FN bool xml_text::set(bool rhs)
-    {
-        xml_node_struct* dn = _data_new();
+	PUGI__FN bool xml_text::set(bool rhs)
+	{
+		xml_node_struct* dn = _data_new();
 
-        return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
-    }
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
 
-    PUGI__FN xml_text& xml_text::operator=(const char_t* rhs)
-    {
-        set(rhs);
-        return *this;
-    }
+	PUGI__FN xml_text& xml_text::operator=(const char_t* rhs)
+	{
+		set(rhs);
+		return *this;
+	}
 
-    PUGI__FN xml_text& xml_text::operator=(int rhs)
-    {
-        set(rhs);
-        return *this;
-    }
+	PUGI__FN xml_text& xml_text::operator=(int rhs)
+	{
+		set(rhs);
+		return *this;
+	}
 
-    PUGI__FN xml_text& xml_text::operator=(unsigned int rhs)
-    {
-        set(rhs);
-        return *this;
-    }
+	PUGI__FN xml_text& xml_text::operator=(unsigned int rhs)
+	{
+		set(rhs);
+		return *this;
+	}
 
-    PUGI__FN xml_text& xml_text::operator=(double rhs)
-    {
-        set(rhs);
-        return *this;
-    }
+	PUGI__FN xml_text& xml_text::operator=(double rhs)
+	{
+		set(rhs);
+		return *this;
+	}
 
-    PUGI__FN xml_text& xml_text::operator=(bool rhs)
-    {
-        set(rhs);
-        return *this;
-    }
+	PUGI__FN xml_text& xml_text::operator=(bool rhs)
+	{
+		set(rhs);
+		return *this;
+	}
 
-    PUGI__FN xml_node xml_text::data() const
-    {
-        return xml_node(_data());
-    }
+	PUGI__FN xml_node xml_text::data() const
+	{
+		return xml_node(_data());
+	}
 
 #ifdef __BORLANDC__
 	PUGI__FN bool operator&&(const xml_text& lhs, bool rhs)
@@ -5019,55 +5019,55 @@ namespace pugi
 		return temp;
 	}
 
-    PUGI__FN xml_named_node_iterator::xml_named_node_iterator(): _name(0)
-    {
-    }
-
-    PUGI__FN xml_named_node_iterator::xml_named_node_iterator(const xml_node& node, const char_t* name): _node(node), _name(name)
-    {
-    }
-
-    PUGI__FN bool xml_named_node_iterator::operator==(const xml_named_node_iterator& rhs) const
-    {
-        return _node == rhs._node;
-    }
-
-    PUGI__FN bool xml_named_node_iterator::operator!=(const xml_named_node_iterator& rhs) const
-    {
-        return _node != rhs._node;
-    }
-
-    PUGI__FN xml_node& xml_named_node_iterator::operator*() const
-    {
-        return _node;
-    }
-
-    PUGI__FN xml_node* xml_named_node_iterator::operator->() const
-    {
-        return &_node;
-    }
-
-    PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator++()
-    {
-        _node = _node.next_sibling(_name);
-        return *this;
-    }
-
-    PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator++(int)
-    {
-        xml_named_node_iterator temp = *this;
-        ++*this;
-        return temp;
-    }
-
-    PUGI__FN xml_parse_result::xml_parse_result(): status(status_internal_error), offset(0), encoding(encoding_auto)
-    {
-    }
-
-    PUGI__FN xml_parse_result::operator bool() const
-    {
-        return status == status_ok;
-    }
+	PUGI__FN xml_named_node_iterator::xml_named_node_iterator(): _name(0)
+	{
+	}
+
+	PUGI__FN xml_named_node_iterator::xml_named_node_iterator(const xml_node& node, const char_t* name): _node(node), _name(name)
+	{
+	}
+
+	PUGI__FN bool xml_named_node_iterator::operator==(const xml_named_node_iterator& rhs) const
+	{
+		return _node == rhs._node;
+	}
+
+	PUGI__FN bool xml_named_node_iterator::operator!=(const xml_named_node_iterator& rhs) const
+	{
+		return _node != rhs._node;
+	}
+
+	PUGI__FN xml_node& xml_named_node_iterator::operator*() const
+	{
+		return _node;
+	}
+
+	PUGI__FN xml_node* xml_named_node_iterator::operator->() const
+	{
+		return &_node;
+	}
+
+	PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator++()
+	{
+		_node = _node.next_sibling(_name);
+		return *this;
+	}
+
+	PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator++(int)
+	{
+		xml_named_node_iterator temp = *this;
+		++*this;
+		return temp;
+	}
+
+	PUGI__FN xml_parse_result::xml_parse_result(): status(status_internal_error), offset(0), encoding(encoding_auto)
+	{
+	}
+
+	PUGI__FN xml_parse_result::operator bool() const
+	{
+		return status == status_ok;
+	}
 
 	PUGI__FN const char* xml_parse_result::description() const
 	{
@@ -5112,13 +5112,13 @@ namespace pugi
 		create();
 	}
 
-    PUGI__FN void xml_document::reset(const xml_document& proto)
-    {
-        reset();
+	PUGI__FN void xml_document::reset(const xml_document& proto)
+	{
+		reset();
 
-        for (xml_node cur = proto.first_child(); cur; cur = cur.next_sibling())
-            append_copy(cur);
-    }
+		for (xml_node cur = proto.first_child(); cur; cur = cur.next_sibling())
+			append_copy(cur);
+	}
 
 	PUGI__FN void xml_document::create()
 	{
@@ -5272,20 +5272,20 @@ namespace pugi
 		impl::xml_buffered_writer buffered_writer(writer, encoding);
 
 		if ((flags & format_write_bom) && encoding != encoding_latin1)
-        {
-            // BOM always represents the codepoint U+FEFF, so just write it in native encoding
-        #ifdef PUGIXML_WCHAR_MODE
-            unsigned int bom = 0xfeff;
-            buffered_writer.write(static_cast<wchar_t>(bom));
-        #else
-            buffered_writer.write('\xef', '\xbb', '\xbf');
-        #endif
-        }
+		{
+			// BOM always represents the codepoint U+FEFF, so just write it in native encoding
+		#ifdef PUGIXML_WCHAR_MODE
+			unsigned int bom = 0xfeff;
+			buffered_writer.write(static_cast<wchar_t>(bom));
+		#else
+			buffered_writer.write('\xef', '\xbb', '\xbf');
+		#endif
+		}
 
 		if (!(flags & format_no_declaration) && !impl::has_declaration(*this))
 		{
 			buffered_writer.write(PUGIXML_TEXT("<?xml version=\"1.0\""));
-            if (encoding == encoding_latin1) buffered_writer.write(PUGIXML_TEXT(" encoding=\"ISO-8859-1\""));
+			if (encoding == encoding_latin1) buffered_writer.write(PUGIXML_TEXT(" encoding=\"ISO-8859-1\""));
 			buffered_writer.write('?', '>');
 			if (!(flags & format_raw)) buffered_writer.write('\n');
 		}
@@ -5312,65 +5312,65 @@ namespace pugi
 	PUGI__FN bool xml_document::save_file(const char* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
 	{
 		FILE* file = fopen(path_, (flags & format_save_file_text) ? "w" : "wb");
-        return impl::save_file_impl(*this, file, indent, flags, encoding);
+		return impl::save_file_impl(*this, file, indent, flags, encoding);
 	}
 
 	PUGI__FN bool xml_document::save_file(const wchar_t* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
 	{
 		FILE* file = impl::open_file_wide(path_, (flags & format_save_file_text) ? L"w" : L"wb");
-        return impl::save_file_impl(*this, file, indent, flags, encoding);
+		return impl::save_file_impl(*this, file, indent, flags, encoding);
 	}
 
-    PUGI__FN xml_node xml_document::document_element() const
-    {
+	PUGI__FN xml_node xml_document::document_element() const
+	{
 		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
 			if ((i->header & impl::xml_memory_page_type_mask) + 1 == node_element)
-                return xml_node(i);
+				return xml_node(i);
 
-        return xml_node();
-    }
+		return xml_node();
+	}
 
 #ifndef PUGIXML_NO_STL
 	PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const wchar_t* str)
 	{
 		assert(str);
 
-        return impl::as_utf8_impl(str, wcslen(str));
+		return impl::as_utf8_impl(str, wcslen(str));
 	}
 
 	PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const std::basic_string<wchar_t>& str)
 	{
-        return impl::as_utf8_impl(str.c_str(), str.size());
+		return impl::as_utf8_impl(str.c_str(), str.size());
 	}
 	
 	PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const char* str)
 	{
 		assert(str);
 
-        return impl::as_wide_impl(str, strlen(str));
+		return impl::as_wide_impl(str, strlen(str));
 	}
 	
 	PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const std::string& str)
 	{
-        return impl::as_wide_impl(str.c_str(), str.size());
+		return impl::as_wide_impl(str.c_str(), str.size());
 	}
 #endif
 
-    PUGI__FN void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate)
-    {
-    	impl::xml_memory::allocate = allocate;
-    	impl::xml_memory::deallocate = deallocate;
-    }
-
-    PUGI__FN allocation_function PUGIXML_FUNCTION get_memory_allocation_function()
-    {
-    	return impl::xml_memory::allocate;
-    }
-
-    PUGI__FN deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function()
-    {
-    	return impl::xml_memory::deallocate;
-    }
+	PUGI__FN void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate)
+	{
+		impl::xml_memory::allocate = allocate;
+		impl::xml_memory::deallocate = deallocate;
+	}
+
+	PUGI__FN allocation_function PUGIXML_FUNCTION get_memory_allocation_function()
+	{
+		return impl::xml_memory::allocate;
+	}
+
+	PUGI__FN deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function()
+	{
+		return impl::xml_memory::deallocate;
+	}
 }
 
 #if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) || defined(__ICC))
@@ -5651,12 +5651,12 @@ PUGI__NS_BEGIN
 		xpath_memory_block* next;
 
 		char data[
-    #ifdef PUGIXML_MEMORY_XPATH_PAGE_SIZE
-            PUGIXML_MEMORY_XPATH_PAGE_SIZE
-    #else
-            4096
-    #endif
-        ];
+	#ifdef PUGIXML_MEMORY_XPATH_PAGE_SIZE
+			PUGIXML_MEMORY_XPATH_PAGE_SIZE
+	#else
+			4096
+	#endif
+		];
 	};
 		
 	class xpath_allocator
@@ -6077,15 +6077,15 @@ PUGI__NS_BEGIN
 	
 	PUGI__FN unsigned int node_height(xml_node n)
 	{
-	    unsigned int result = 0;
-	    
-	    while (n)
-	    {
-	        ++result;
-	        n = n.parent();
-	    }
-	    
-	    return result;
+		unsigned int result = 0;
+		
+		while (n)
+		{
+			++result;
+			n = n.parent();
+		}
+		
+		return result;
 	}
 	
 	PUGI__FN bool node_is_before(xml_node ln, unsigned int lh, xml_node rn, unsigned int rh)
@@ -6093,58 +6093,58 @@ PUGI__NS_BEGIN
 		// normalize heights
 		for (unsigned int i = rh; i < lh; i++) ln = ln.parent();
 		for (unsigned int j = lh; j < rh; j++) rn = rn.parent();
-	    
+		
 		// one node is the ancestor of the other
-	    if (ln == rn) return lh < rh;
-	    
+		if (ln == rn) return lh < rh;
+		
 		// find common ancestor
-	    while (ln.parent() != rn.parent())
-	    {
-	        ln = ln.parent();
-	        rn = rn.parent();
-	    }
+		while (ln.parent() != rn.parent())
+		{
+			ln = ln.parent();
+			rn = rn.parent();
+		}
 
 		// there is no common ancestor (the shared parent is null), nodes are from different documents
 		if (!ln.parent()) return ln < rn;
 
 		// determine sibling order
-        for (; ln; ln = ln.next_sibling())
-            if (ln == rn)
-                return true;
-                
-        return false;
-    }
-
-    PUGI__FN bool node_is_ancestor(xml_node parent, xml_node node)
-    {
-    	while (node && node != parent) node = node.parent();
-
-    	return parent && node == parent;
-    }
-
-    PUGI__FN const void* document_order(const xpath_node& xnode)
-    {
-        xml_node_struct* node = xnode.node().internal_object();
-
-        if (node)
-        {
-            if (node->name && (node->header & xml_memory_page_name_allocated_mask) == 0) return node->name;
-            if (node->value && (node->header & xml_memory_page_value_allocated_mask) == 0) return node->value;
-            return 0;
-        }
-
-        xml_attribute_struct* attr = xnode.attribute().internal_object();
-
-        if (attr)
-        {
-            if ((attr->header & xml_memory_page_name_allocated_mask) == 0) return attr->name;
-            if ((attr->header & xml_memory_page_value_allocated_mask) == 0) return attr->value;
-            return 0;
-        }
+		for (; ln; ln = ln.next_sibling())
+			if (ln == rn)
+				return true;
+				
+		return false;
+	}
+
+	PUGI__FN bool node_is_ancestor(xml_node parent, xml_node node)
+	{
+		while (node && node != parent) node = node.parent();
+
+		return parent && node == parent;
+	}
+
+	PUGI__FN const void* document_order(const xpath_node& xnode)
+	{
+		xml_node_struct* node = xnode.node().internal_object();
+
+		if (node)
+		{
+			if (node->name && (node->header & xml_memory_page_name_allocated_mask) == 0) return node->name;
+			if (node->value && (node->header & xml_memory_page_value_allocated_mask) == 0) return node->value;
+			return 0;
+		}
+
+		xml_attribute_struct* attr = xnode.attribute().internal_object();
+
+		if (attr)
+		{
+			if ((attr->header & xml_memory_page_name_allocated_mask) == 0) return attr->name;
+			if ((attr->header & xml_memory_page_value_allocated_mask) == 0) return attr->value;
+			return 0;
+		}
 
 		return 0;
-    }
-    
+	}
+	
 	struct document_order_comparator
 	{
 		bool operator()(const xpath_node& lhs, const xpath_node& rhs) const
@@ -6155,7 +6155,7 @@ PUGI__NS_BEGIN
 
 			if (lo && ro) return lo < ro;
 
-            // slow comparison
+			// slow comparison
 			xml_node ln = lhs.node(), rn = rhs.node();
 
 			// compare attributes
@@ -6165,11 +6165,11 @@ PUGI__NS_BEGIN
 				if (lhs.parent() == rhs.parent())
 				{
 					// determine sibling order
-				    for (xml_attribute a = lhs.attribute(); a; a = a.next_attribute())
-				        if (a == rhs.attribute())
-				            return true;
-				    
-				    return false;
+					for (xml_attribute a = lhs.attribute(); a; a = a.next_attribute())
+						if (a == rhs.attribute())
+							return true;
+					
+					return false;
 				}
 				
 				// compare attribute parents
@@ -6248,7 +6248,7 @@ PUGI__NS_BEGIN
 			return PUGIXML_TEXT("NaN");
 
 		case FP_INFINITE:
-            return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
+			return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
 
 		case FP_ZERO:
 			return PUGIXML_TEXT("0");
@@ -7278,7 +7278,7 @@ PUGI__NS_BEGIN
 		ast_op_or,						// left or right
 		ast_op_and,						// left and right
 		ast_op_equal,					// left = right
-		ast_op_not_equal, 				// left != right
+		ast_op_not_equal,				// left != right
 		ast_op_less,					// left < right
 		ast_op_greater,					// left > right
 		ast_op_less_or_equal,			// left <= right
@@ -8562,7 +8562,7 @@ PUGI__NS_BEGIN
 				xpath_node_set_raw rs = _right->eval_node_set(c, stack);
 				
 				// we can optimize merging two sorted sets, but this is a very rare operation, so don't bother
-  		        rs.set_type(xpath_node_set::type_unsorted);
+				rs.set_type(xpath_node_set::type_unsorted);
 
 				rs.append(ls.begin(), ls.end(), stack.result);
 				rs.remove_duplicates();
@@ -8630,9 +8630,9 @@ PUGI__NS_BEGIN
 				case axis_self:
 					return step_do(c, stack, axis_to_type<axis_self>());
 
-                default:
-                    assert(!"Unknown axis");
-                    return xpath_node_set_raw();
+				default:
+					assert(!"Unknown axis");
+					return xpath_node_set_raw();
 				}
 			}
 
@@ -8714,8 +8714,8 @@ PUGI__NS_BEGIN
 
 	struct xpath_parser
 	{
-	    xpath_allocator* _alloc;
-	    xpath_lexer _lexer;
+		xpath_allocator* _alloc;
+		xpath_lexer _lexer;
 
 		const char_t* _query;
 		xpath_variable_set* _variables;
@@ -8739,13 +8739,13 @@ PUGI__NS_BEGIN
 		}
 
 		void throw_error_oom()
-        {
-        #ifdef PUGIXML_NO_EXCEPTIONS
-            throw_error("Out of memory");
-        #else
-            throw std::bad_alloc();
-        #endif
-        }
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			throw_error("Out of memory");
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
 
 		void* alloc_node()
 		{
@@ -8886,8 +8886,8 @@ PUGI__NS_BEGIN
 					
 				break;
 
-            default:
-                break;
+			default:
+				break;
 			}
 
 			throw_error("Unrecognized function or wrong parameter count");
@@ -8955,8 +8955,8 @@ PUGI__NS_BEGIN
 				
 				break;
 
-            default:
-                break;
+			default:
+				break;
 			}
 
 			specified = false;
@@ -8990,21 +8990,21 @@ PUGI__NS_BEGIN
 					return nodetest_type_text;
 
 				break;
-            
-            default:
-                break;
+			
+			default:
+				break;
 			}
 
-            return nodetest_none;
+			return nodetest_none;
 		}
 
-	    // PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
-	    xpath_ast_node* parse_primary_expression()
-	    {
-	    	switch (_lexer.current())
-	    	{
-	    	case lex_var_ref:
-	    	{
+		// PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+		xpath_ast_node* parse_primary_expression()
+		{
+			switch (_lexer.current())
+			{
+			case lex_var_ref:
+			{
 				xpath_lexer_string name = _lexer.contents();
 
 				if (!_variables)
@@ -9017,7 +9017,7 @@ PUGI__NS_BEGIN
 
 				_lexer.next();
 
-	    		return new (alloc_node()) xpath_ast_node(ast_variable, var->type(), var);
+				return new (alloc_node()) xpath_ast_node(ast_variable, var->type(), var);
 			}
 
 			case lex_open_brace:
@@ -9094,23 +9094,23 @@ PUGI__NS_BEGIN
 				return parse_function(function, argc, args);
 			}
 
-	    	default:
-	    		throw_error("Unrecognizable primary expression");
+			default:
+				throw_error("Unrecognizable primary expression");
 
-	    		return 0;
-	    	}
-	    }
-	    
-	    // FilterExpr ::= PrimaryExpr | FilterExpr Predicate
-	    // Predicate ::= '[' PredicateExpr ']'
-	    // PredicateExpr ::= Expr
-	    xpath_ast_node* parse_filter_expression()
-	    {
-	    	xpath_ast_node* n = parse_primary_expression();
+				return 0;
+			}
+		}
+		
+		// FilterExpr ::= PrimaryExpr | FilterExpr Predicate
+		// Predicate ::= '[' PredicateExpr ']'
+		// PredicateExpr ::= Expr
+		xpath_ast_node* parse_filter_expression()
+		{
+			xpath_ast_node* n = parse_primary_expression();
 
-	    	while (_lexer.current() == lex_open_square_brace)
-	    	{
-	    		_lexer.next();
+			while (_lexer.current() == lex_open_square_brace)
+			{
+				_lexer.next();
 
 				xpath_ast_node* expr = parse_expression();
 
@@ -9118,24 +9118,24 @@ PUGI__NS_BEGIN
 
 				bool posinv = expr->rettype() != xpath_type_number && expr->is_posinv();
 
-	    		n = new (alloc_node()) xpath_ast_node(posinv ? ast_filter_posinv : ast_filter, xpath_type_node_set, n, expr);
-
-	    		if (_lexer.current() != lex_close_square_brace)
-	    			throw_error("Unmatched square brace");
-	    	
-	    		_lexer.next();
-	    	}
-	    	
-	    	return n;
-	    }
-	    
-	    // Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
-	    // AxisSpecifier ::= AxisName '::' | '@'?
-	    // NodeTest ::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
-	    // NameTest ::= '*' | NCName ':' '*' | QName
-	    // AbbreviatedStep ::= '.' | '..'
-	    xpath_ast_node* parse_step(xpath_ast_node* set)
-	    {
+				n = new (alloc_node()) xpath_ast_node(posinv ? ast_filter_posinv : ast_filter, xpath_type_node_set, n, expr);
+
+				if (_lexer.current() != lex_close_square_brace)
+					throw_error("Unmatched square brace");
+			
+				_lexer.next();
+			}
+			
+			return n;
+		}
+		
+		// Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
+		// AxisSpecifier ::= AxisName '::' | '@'?
+		// NodeTest ::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
+		// NameTest ::= '*' | NCName ':' '*' | QName
+		// AbbreviatedStep ::= '.' | '..'
+		xpath_ast_node* parse_step(xpath_ast_node* set)
+		{
 			if (set && set->rettype() != xpath_type_node_set)
 				throw_error("Step has to be applied to node set");
 
@@ -9161,7 +9161,7 @@ PUGI__NS_BEGIN
 				
 				return new (alloc_node()) xpath_ast_node(ast_step, set, axis_parent, nodetest_type_node, 0);
 			}
-	    
+		
 			nodetest_t nt_type = nodetest_none;
 			xpath_lexer_string nt_name;
 			
@@ -9265,7 +9265,7 @@ PUGI__NS_BEGIN
 				xpath_ast_node* pred = new (alloc_node()) xpath_ast_node(ast_predicate, xpath_type_node_set, expr);
 				
 				if (_lexer.current() != lex_close_square_brace)
-	    			throw_error("Unmatched square brace");
+					throw_error("Unmatched square brace");
 				_lexer.next();
 				
 				if (last) last->set_next(pred);
@@ -9275,11 +9275,11 @@ PUGI__NS_BEGIN
 			}
 			
 			return n;
-	    }
-	    
-	    // RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
-	    xpath_ast_node* parse_relative_location_path(xpath_ast_node* set)
-	    {
+		}
+		
+		// RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
+		xpath_ast_node* parse_relative_location_path(xpath_ast_node* set)
+		{
 			xpath_ast_node* n = parse_step(set);
 			
 			while (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
@@ -9294,12 +9294,12 @@ PUGI__NS_BEGIN
 			}
 			
 			return n;
-	    }
-	    
-	    // LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
-	    // AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
-	    xpath_ast_node* parse_location_path()
-	    {
+		}
+		
+		// LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
+		// AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
+		xpath_ast_node* parse_location_path()
+		{
 			if (_lexer.current() == lex_slash)
 			{
 				_lexer.next();
@@ -9326,14 +9326,14 @@ PUGI__NS_BEGIN
 
 			// else clause moved outside of if because of bogus warning 'control may reach end of non-void function being inlined' in gcc 4.0.1
 			return parse_relative_location_path(0);
-	    }
-	    
-	    // PathExpr ::= LocationPath
-	    //				| FilterExpr
-	    //				| FilterExpr '/' RelativeLocationPath
-	    //				| FilterExpr '//' RelativeLocationPath
-	    xpath_ast_node* parse_path_expression()
-	    {
+		}
+		
+		// PathExpr ::= LocationPath
+		//				| FilterExpr
+		//				| FilterExpr '/' RelativeLocationPath
+		//				| FilterExpr '//' RelativeLocationPath
+		xpath_ast_node* parse_path_expression()
+		{
 			// Clarification.
 			// PathExpr begins with either LocationPath or FilterExpr.
 			// FilterExpr begins with PrimaryExpr
@@ -9344,27 +9344,27 @@ PUGI__NS_BEGIN
 			if (_lexer.current() == lex_var_ref || _lexer.current() == lex_open_brace || 
 				_lexer.current() == lex_quoted_string || _lexer.current() == lex_number ||
 				_lexer.current() == lex_string)
-	    	{
-	    		if (_lexer.current() == lex_string)
-	    		{
-	    			// This is either a function call, or not - if not, we shall proceed with location path
-	    			const char_t* state = _lexer.state();
-	    			
+			{
+				if (_lexer.current() == lex_string)
+				{
+					// This is either a function call, or not - if not, we shall proceed with location path
+					const char_t* state = _lexer.state();
+					
 					while (PUGI__IS_CHARTYPE(*state, ct_space)) ++state;
-	    			
-	    			if (*state != '(') return parse_location_path();
+					
+					if (*state != '(') return parse_location_path();
 
 					// This looks like a function call; however this still can be a node-test. Check it.
 					if (parse_node_test_type(_lexer.contents()) != nodetest_none) return parse_location_path();
-	    		}
-	    		
-	    		xpath_ast_node* n = parse_filter_expression();
+				}
+				
+				xpath_ast_node* n = parse_filter_expression();
 
-	    		if (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
-	    		{
+				if (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
+				{
 					lexeme_t l = _lexer.current();
-	    			_lexer.next();
-	    			
+					_lexer.next();
+					
 					if (l == lex_double_slash)
 					{
 						if (n->rettype() != xpath_type_node_set) throw_error("Step has to be applied to node set");
@@ -9372,171 +9372,171 @@ PUGI__NS_BEGIN
 						n = new (alloc_node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
 					}
 	
-	    			// select from location path
-	    			return parse_relative_location_path(n);
-	    		}
+					// select from location path
+					return parse_relative_location_path(n);
+				}
 
-	    		return n;
-	    	}
-	    	else return parse_location_path();
-	    }
+				return n;
+			}
+			else return parse_location_path();
+		}
 
-	    // UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
-	    xpath_ast_node* parse_union_expression()
-	    {
-	    	xpath_ast_node* n = parse_path_expression();
+		// UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
+		xpath_ast_node* parse_union_expression()
+		{
+			xpath_ast_node* n = parse_path_expression();
 
-	    	while (_lexer.current() == lex_union)
-	    	{
-	    		_lexer.next();
+			while (_lexer.current() == lex_union)
+			{
+				_lexer.next();
 
 				xpath_ast_node* expr = parse_union_expression();
 
 				if (n->rettype() != xpath_type_node_set || expr->rettype() != xpath_type_node_set)
 					throw_error("Union operator has to be applied to node sets");
 
-	    		n = new (alloc_node()) xpath_ast_node(ast_op_union, xpath_type_node_set, n, expr);
-	    	}
+				n = new (alloc_node()) xpath_ast_node(ast_op_union, xpath_type_node_set, n, expr);
+			}
 
-	    	return n;
-	    }
+			return n;
+		}
 
-	    // UnaryExpr ::= UnionExpr | '-' UnaryExpr
-	    xpath_ast_node* parse_unary_expression()
-	    {
-	    	if (_lexer.current() == lex_minus)
-	    	{
-	    		_lexer.next();
+		// UnaryExpr ::= UnionExpr | '-' UnaryExpr
+		xpath_ast_node* parse_unary_expression()
+		{
+			if (_lexer.current() == lex_minus)
+			{
+				_lexer.next();
 
 				xpath_ast_node* expr = parse_unary_expression();
 
-	    		return new (alloc_node()) xpath_ast_node(ast_op_negate, xpath_type_number, expr);
-	    	}
-	    	else return parse_union_expression();
-	    }
-	    
-	    // MultiplicativeExpr ::= UnaryExpr
-	    //						  | MultiplicativeExpr '*' UnaryExpr
-	    //						  | MultiplicativeExpr 'div' UnaryExpr
-	    //						  | MultiplicativeExpr 'mod' UnaryExpr
-	    xpath_ast_node* parse_multiplicative_expression()
-	    {
-	    	xpath_ast_node* n = parse_unary_expression();
-
-	    	while (_lexer.current() == lex_multiply || (_lexer.current() == lex_string &&
-	    		   (_lexer.contents() == PUGIXML_TEXT("mod") || _lexer.contents() == PUGIXML_TEXT("div"))))
-	    	{
-	    		ast_type_t op = _lexer.current() == lex_multiply ? ast_op_multiply :
-	    			_lexer.contents().begin[0] == 'd' ? ast_op_divide : ast_op_mod;
-	    		_lexer.next();
+				return new (alloc_node()) xpath_ast_node(ast_op_negate, xpath_type_number, expr);
+			}
+			else return parse_union_expression();
+		}
+		
+		// MultiplicativeExpr ::= UnaryExpr
+		//						  | MultiplicativeExpr '*' UnaryExpr
+		//						  | MultiplicativeExpr 'div' UnaryExpr
+		//						  | MultiplicativeExpr 'mod' UnaryExpr
+		xpath_ast_node* parse_multiplicative_expression()
+		{
+			xpath_ast_node* n = parse_unary_expression();
+
+			while (_lexer.current() == lex_multiply || (_lexer.current() == lex_string &&
+				   (_lexer.contents() == PUGIXML_TEXT("mod") || _lexer.contents() == PUGIXML_TEXT("div"))))
+			{
+				ast_type_t op = _lexer.current() == lex_multiply ? ast_op_multiply :
+					_lexer.contents().begin[0] == 'd' ? ast_op_divide : ast_op_mod;
+				_lexer.next();
 
 				xpath_ast_node* expr = parse_unary_expression();
 
-	    		n = new (alloc_node()) xpath_ast_node(op, xpath_type_number, n, expr);
-	    	}
+				n = new (alloc_node()) xpath_ast_node(op, xpath_type_number, n, expr);
+			}
 
-	    	return n;
-	    }
+			return n;
+		}
 
-	    // AdditiveExpr ::= MultiplicativeExpr
-	    //					| AdditiveExpr '+' MultiplicativeExpr
-	    //					| AdditiveExpr '-' MultiplicativeExpr
-	    xpath_ast_node* parse_additive_expression()
-	    {
-	    	xpath_ast_node* n = parse_multiplicative_expression();
+		// AdditiveExpr ::= MultiplicativeExpr
+		//					| AdditiveExpr '+' MultiplicativeExpr
+		//					| AdditiveExpr '-' MultiplicativeExpr
+		xpath_ast_node* parse_additive_expression()
+		{
+			xpath_ast_node* n = parse_multiplicative_expression();
 
-	    	while (_lexer.current() == lex_plus || _lexer.current() == lex_minus)
-	    	{
-	    		lexeme_t l = _lexer.current();
+			while (_lexer.current() == lex_plus || _lexer.current() == lex_minus)
+			{
+				lexeme_t l = _lexer.current();
 
-	    		_lexer.next();
+				_lexer.next();
 
 				xpath_ast_node* expr = parse_multiplicative_expression();
 
-	    		n = new (alloc_node()) xpath_ast_node(l == lex_plus ? ast_op_add : ast_op_subtract, xpath_type_number, n, expr);
-	    	}
+				n = new (alloc_node()) xpath_ast_node(l == lex_plus ? ast_op_add : ast_op_subtract, xpath_type_number, n, expr);
+			}
 
-	    	return n;
-	    }
+			return n;
+		}
 
-	    // RelationalExpr ::= AdditiveExpr
-	    //					  | RelationalExpr '<' AdditiveExpr
-	    //					  | RelationalExpr '>' AdditiveExpr
-	    //					  | RelationalExpr '<=' AdditiveExpr
-	    //					  | RelationalExpr '>=' AdditiveExpr
-	    xpath_ast_node* parse_relational_expression()
-	    {
-	    	xpath_ast_node* n = parse_additive_expression();
+		// RelationalExpr ::= AdditiveExpr
+		//					  | RelationalExpr '<' AdditiveExpr
+		//					  | RelationalExpr '>' AdditiveExpr
+		//					  | RelationalExpr '<=' AdditiveExpr
+		//					  | RelationalExpr '>=' AdditiveExpr
+		xpath_ast_node* parse_relational_expression()
+		{
+			xpath_ast_node* n = parse_additive_expression();
 
-	    	while (_lexer.current() == lex_less || _lexer.current() == lex_less_or_equal || 
-	    		   _lexer.current() == lex_greater || _lexer.current() == lex_greater_or_equal)
-	    	{
-	    		lexeme_t l = _lexer.current();
-	    		_lexer.next();
+			while (_lexer.current() == lex_less || _lexer.current() == lex_less_or_equal || 
+				   _lexer.current() == lex_greater || _lexer.current() == lex_greater_or_equal)
+			{
+				lexeme_t l = _lexer.current();
+				_lexer.next();
 
 				xpath_ast_node* expr = parse_additive_expression();
 
-	    		n = new (alloc_node()) xpath_ast_node(l == lex_less ? ast_op_less : l == lex_greater ? ast_op_greater :
-	    						l == lex_less_or_equal ? ast_op_less_or_equal : ast_op_greater_or_equal, xpath_type_boolean, n, expr);
-	    	}
+				n = new (alloc_node()) xpath_ast_node(l == lex_less ? ast_op_less : l == lex_greater ? ast_op_greater :
+								l == lex_less_or_equal ? ast_op_less_or_equal : ast_op_greater_or_equal, xpath_type_boolean, n, expr);
+			}
 
-	    	return n;
-	    }
-	    
-	    // EqualityExpr ::= RelationalExpr
-	    //					| EqualityExpr '=' RelationalExpr
-	    //					| EqualityExpr '!=' RelationalExpr
-	    xpath_ast_node* parse_equality_expression()
-	    {
-	    	xpath_ast_node* n = parse_relational_expression();
+			return n;
+		}
+		
+		// EqualityExpr ::= RelationalExpr
+		//					| EqualityExpr '=' RelationalExpr
+		//					| EqualityExpr '!=' RelationalExpr
+		xpath_ast_node* parse_equality_expression()
+		{
+			xpath_ast_node* n = parse_relational_expression();
 
-	    	while (_lexer.current() == lex_equal || _lexer.current() == lex_not_equal)
-	    	{
-	    		lexeme_t l = _lexer.current();
+			while (_lexer.current() == lex_equal || _lexer.current() == lex_not_equal)
+			{
+				lexeme_t l = _lexer.current();
 
-	    		_lexer.next();
+				_lexer.next();
 
 				xpath_ast_node* expr = parse_relational_expression();
 
-	    		n = new (alloc_node()) xpath_ast_node(l == lex_equal ? ast_op_equal : ast_op_not_equal, xpath_type_boolean, n, expr);
-	    	}
+				n = new (alloc_node()) xpath_ast_node(l == lex_equal ? ast_op_equal : ast_op_not_equal, xpath_type_boolean, n, expr);
+			}
 
-	    	return n;
-	    }
-	    
-	    // AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
-	    xpath_ast_node* parse_and_expression()
-	    {
-	    	xpath_ast_node* n = parse_equality_expression();
+			return n;
+		}
+		
+		// AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
+		xpath_ast_node* parse_and_expression()
+		{
+			xpath_ast_node* n = parse_equality_expression();
 
-	    	while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("and"))
-	    	{
-	    		_lexer.next();
+			while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("and"))
+			{
+				_lexer.next();
 
 				xpath_ast_node* expr = parse_equality_expression();
 
-	    		n = new (alloc_node()) xpath_ast_node(ast_op_and, xpath_type_boolean, n, expr);
-	    	}
+				n = new (alloc_node()) xpath_ast_node(ast_op_and, xpath_type_boolean, n, expr);
+			}
 
-	    	return n;
-	    }
+			return n;
+		}
 
-	    // OrExpr ::= AndExpr | OrExpr 'or' AndExpr
-	    xpath_ast_node* parse_or_expression()
-	    {
-	    	xpath_ast_node* n = parse_and_expression();
+		// OrExpr ::= AndExpr | OrExpr 'or' AndExpr
+		xpath_ast_node* parse_or_expression()
+		{
+			xpath_ast_node* n = parse_and_expression();
 
-	    	while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("or"))
-	    	{
-	    		_lexer.next();
+			while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("or"))
+			{
+				_lexer.next();
 
 				xpath_ast_node* expr = parse_and_expression();
 
-	    		n = new (alloc_node()) xpath_ast_node(ast_op_or, xpath_type_boolean, n, expr);
-	    	}
+				n = new (alloc_node()) xpath_ast_node(ast_op_or, xpath_type_boolean, n, expr);
+			}
 
-	    	return n;
-	    }
+			return n;
+		}
 		
 		// Expr ::= OrExpr
 		xpath_ast_node* parse_expression()
@@ -9575,13 +9575,13 @@ PUGI__NS_BEGIN
 		}
 	};
 
-    struct xpath_query_impl
-    {
+	struct xpath_query_impl
+	{
 		static xpath_query_impl* create()
 		{
 			void* memory = xml_memory::allocate(sizeof(xpath_query_impl));
 
-            return new (memory) xpath_query_impl();
+			return new (memory) xpath_query_impl();
 		}
 
 		static void destroy(void* ptr)
@@ -9595,15 +9595,15 @@ PUGI__NS_BEGIN
 			xml_memory::deallocate(ptr);
 		}
 
-        xpath_query_impl(): root(0), alloc(&block)
-        {
-            block.next = 0;
-        }
+		xpath_query_impl(): root(0), alloc(&block)
+		{
+			block.next = 0;
+		}
 
-        xpath_ast_node* root;
-        xpath_allocator alloc;
-        xpath_memory_block block;
-    };
+		xpath_ast_node* root;
+		xpath_allocator alloc;
+		xpath_memory_block block;
+	};
 
 	PUGI__FN xpath_string evaluate_string_impl(xpath_query_impl* impl, const xpath_node& n, xpath_stack_data& sd)
 	{
@@ -9665,9 +9665,9 @@ namespace pugi
 		return _attribute ? _node : _node.parent();
 	}
 
-    PUGI__FN static void unspecified_bool_xpath_node(xpath_node***)
-    {
-    }
+	PUGI__FN static void unspecified_bool_xpath_node(xpath_node***)
+	{
+	}
 
 	PUGI__FN xpath_node::operator xpath_node::unspecified_bool_type() const
 	{
@@ -9813,14 +9813,14 @@ namespace pugi
 		return impl::xpath_first(_begin, _end, _type);
 	}
 
-    PUGI__FN xpath_parse_result::xpath_parse_result(): error("Internal error"), offset(0)
-    {
-    }
+	PUGI__FN xpath_parse_result::xpath_parse_result(): error("Internal error"), offset(0)
+	{
+	}
 
-    PUGI__FN xpath_parse_result::operator bool() const
-    {
-        return error == 0;
-    }
+	PUGI__FN xpath_parse_result::operator bool() const
+	{
+		return error == 0;
+	}
 
 	PUGI__FN const char* xpath_parse_result::description() const
 	{
@@ -9828,8 +9828,8 @@ namespace pugi
 	}
 
 	PUGI__FN xpath_variable::xpath_variable()
-    {
-    }
+	{
+	}
 
 	PUGI__FN const char_t* xpath_variable::name() const
 	{
@@ -10025,7 +10025,7 @@ namespace pugi
 		{
 		#ifdef PUGIXML_NO_EXCEPTIONS
 			_result.error = "Out of memory";
-        #else
+		#else
 			throw std::bad_alloc();
 		#endif
 		}
@@ -10037,7 +10037,7 @@ namespace pugi
 
 			if (qimpl->root)
 			{
-                _impl = static_cast<impl::xpath_query_impl*>(impl_holder.release());
+				_impl = static_cast<impl::xpath_query_impl*>(impl_holder.release());
 				_result.error = 0;
 			}
 		}
@@ -10101,13 +10101,13 @@ namespace pugi
 		size_t full_size = r.length() + 1;
 		
 		if (capacity > 0)
-        {
-            size_t size = (full_size < capacity) ? full_size : capacity;
-            assert(size > 0);
+		{
+			size_t size = (full_size < capacity) ? full_size : capacity;
+			assert(size > 0);
 
-            memcpy(buffer, r.c_str(), (size - 1) * sizeof(char_t));
-            buffer[size - 1] = 0;
-        }
+			memcpy(buffer, r.c_str(), (size - 1) * sizeof(char_t));
+			buffer[size - 1] = 0;
+		}
 		
 		return full_size;
 	}
@@ -10116,7 +10116,7 @@ namespace pugi
 	{
 		if (!_impl) return xpath_node_set();
 
-        impl::xpath_ast_node* root = static_cast<impl::xpath_query_impl*>(_impl)->root;
+		impl::xpath_ast_node* root = static_cast<impl::xpath_query_impl*>(_impl)->root;
 
 		if (root->rettype() != xpath_type_node_set)
 		{
@@ -10147,9 +10147,9 @@ namespace pugi
 		return _result;
 	}
 
-    PUGI__FN static void unspecified_bool_xpath_query(xpath_query***)
-    {
-    }
+	PUGI__FN static void unspecified_bool_xpath_query(xpath_query***)
+	{
+	}
 
 	PUGI__FN xpath_query::operator xpath_query::unspecified_bool_type() const
 	{
@@ -10193,13 +10193,13 @@ namespace pugi
 // #endif
 
 #ifdef __BORLANDC__
-#   pragma option pop
+#	pragma option pop
 #endif
 
 // Intel C++ does not properly keep warning state for function templates,
 // so popping warning state at the end of translation unit leads to warnings in the middle.
 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
-#   pragma warning(pop)
+#	pragma warning(pop)
 #endif
 
 // Undefine all local macros (makes sure we're not leaking macros in header-only mode)