open_source / pugixml

Browse Code »

Commit 5b746131ca353a48ab13b60e6b0a30984b653a97

Authored by Steven de Ridder 2022-01-25 09:44:22 +0100

0 parents

Initial commit.

Inline Side-by-side

Showing 9 changed files with 14690 additions and 0 deletions

.gitignore 0 → 100644

View file @5b74613

	1	+++ a/.gitignore
	1	+build/
	2	+CMakeLists.txt.user
...	...

CMakeLists.txt 0 → 100644

View file @5b74613

	1	+++ a/CMakeLists.txt
	1	+cmake_minimum_required(VERSION 3.0)
	2	+
	3	+# Check to see where cmake is located.
	4	+if( IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/cmake )
	5	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
	6	+elseif( IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../cmake )
	7	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../cmake)
	8	+else()
	9	+ return()
	10	+endif()
	11	+
	12	+# Check to see if there is versioning information available
	13	+if(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/osdev_versioning/cmake)
	14	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/osdev_versioning/cmake)
	15	+ include(osdevversion)
	16	+endif()
	17	+
	18	+include(projectheader)
	19	+project_header(osdev_pugixml)
	20	+
	21	+add_subdirectory(src)
	22	+add_subdirectory(tests)
	23	+
	24	+# include(packaging)
	25	+# package_component()
...	...

README.md 0 → 100644

View file @5b74613

	1	+++ a/README.md
...	...

src/CMakeLists.txt 0 → 100644

View file @5b74613

	1	+++ a/src/CMakeLists.txt
	1	+cmake_minimum_required(VERSION 3.4)
	2	+project(pugixml VERSION 1.11 LANGUAGES CXX)
	3	+
	4	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake)
	5	+
	6	+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
	7	+
	8	+set(SRC_LIST
	9	+ ${CMAKE_CURRENT_SOURCE_DIR}/pugiconfig.h
	10	+ ${CMAKE_CURRENT_SOURCE_DIR}/pugixml.h
	11	+ ${CMAKE_CURRENT_SOURCE_DIR}/pugixml.cpp
	12	+)
	13	+
	14	+include(library)
	15	+add_libraries()
	16	+
	17	+include(installation)
	18	+install_component()
...	...

src/README.md 0 → 100644

View file @5b74613

	1	+++ a/src/README.md
	1	+Based on Pugi::XML 1.11
...	...

src/pugiconfig.h 0 → 100644

View file @5b74613

	1	+++ a/src/pugiconfig.h
	1	+/**
	2	+ * pugixml parser - version 1.11
	3	+ * --------------------------------------------------------
	4	+ * Copyright (C) 2006-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
	5	+ * Report bugs and download new versions at https://pugixml.org/
	6	+ *
	7	+ * This library is distributed under the MIT License. See notice at the end
	8	+ * of this file.
	9	+ *
	10	+ * This work is based on the pugxml parser, which is:
	11	+ * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
	12	+ */
	13	+
	14	+#ifndef HEADER_PUGICONFIG_HPP
	15	+#define HEADER_PUGICONFIG_HPP
	16	+
	17	+// Uncomment this to enable wchar_t mode
	18	+// #define PUGIXML_WCHAR_MODE
	19	+
	20	+// Uncomment this to enable compact mode
	21	+// #define PUGIXML_COMPACT
	22	+
	23	+// Uncomment this to disable XPath
	24	+// #define PUGIXML_NO_XPATH
	25	+
	26	+// Uncomment this to disable STL
	27	+// #define PUGIXML_NO_STL
	28	+
	29	+// Uncomment this to disable exceptions
	30	+// #define PUGIXML_NO_EXCEPTIONS
	31	+
	32	+// Set this to control attributes for public classes/functions, i.e.:
	33	+// #define PUGIXML_API __declspec(dllexport) // to export all public symbols from DLL
	34	+// #define PUGIXML_CLASS __declspec(dllimport) // to import all classes from DLL
	35	+// #define PUGIXML_FUNCTION __fastcall // to set calling conventions to all public functions to fastcall
	36	+// In absence of PUGIXML_CLASS/PUGIXML_FUNCTION definitions PUGIXML_API is used instead
	37	+
	38	+// Tune these constants to adjust memory-related behavior
	39	+// #define PUGIXML_MEMORY_PAGE_SIZE 32768
	40	+// #define PUGIXML_MEMORY_OUTPUT_STACK 10240
	41	+// #define PUGIXML_MEMORY_XPATH_PAGE_SIZE 4096
	42	+
	43	+// Tune this constant to adjust max nesting for XPath queries
	44	+// #define PUGIXML_XPATH_DEPTH_LIMIT 1024
	45	+
	46	+// Uncomment this to switch to header-only version
	47	+// #define PUGIXML_HEADER_ONLY
	48	+
	49	+// Uncomment this to enable long long support
	50	+// #define PUGIXML_HAS_LONG_LONG
	51	+
	52	+#endif
	53	+
	54	+/**
	55	+ * Copyright (c) 2006-2020 Arseny Kapoulkine
	56	+ *
	57	+ * Permission is hereby granted, free of charge, to any person
	58	+ * obtaining a copy of this software and associated documentation
	59	+ * files (the "Software"), to deal in the Software without
	60	+ * restriction, including without limitation the rights to use,
	61	+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
	62	+ * copies of the Software, and to permit persons to whom the
	63	+ * Software is furnished to do so, subject to the following
	64	+ * conditions:
	65	+ *
	66	+ * The above copyright notice and this permission notice shall be
	67	+ * included in all copies or substantial portions of the Software.
	68	+ *
	69	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	70	+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
	71	+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	72	+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
	73	+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	74	+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	75	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	76	+ * OTHER DEALINGS IN THE SOFTWARE.
	77	+ */
...	...

src/pugixml.cpp 0 → 100644

View file @5b74613

Changes suppressed. Click to show

	1	+++ a/src/pugixml.cpp
	1	+/**
	2	+ * pugixml parser - version 1.11
	3	+ * --------------------------------------------------------
	4	+ * Copyright (C) 2006-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
	5	+ * Report bugs and download new versions at https://pugixml.org/
	6	+ *
	7	+ * This library is distributed under the MIT License. See notice at the end
	8	+ * of this file.
	9	+ *
	10	+ * This work is based on the pugxml parser, which is:
	11	+ * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
	12	+ */
	13	+
	14	+#ifndef SOURCE_PUGIXML_CPP
	15	+#define SOURCE_PUGIXML_CPP
	16	+
	17	+#include "pugixml.h"
	18	+
	19	+#include <stdlib.h>
	20	+#include <stdio.h>
	21	+#include <string.h>
	22	+#include <assert.h>
	23	+#include <limits.h>
	24	+
	25	+#ifdef PUGIXML_WCHAR_MODE
	26	+# include <wchar.h>
	27	+#endif
	28	+
	29	+#ifndef PUGIXML_NO_XPATH
	30	+# include <math.h>
	31	+# include <float.h>
	32	+#endif
	33	+
	34	+#ifndef PUGIXML_NO_STL
	35	+# include <istream>
	36	+# include <ostream>
	37	+# include <string>
	38	+#endif
	39	+
	40	+// For placement new
	41	+#include <new>
	42	+
	43	+#ifdef _MSC_VER
	44	+# pragma warning(push)
	45	+# pragma warning(disable: 4127) // conditional expression is constant
	46	+# pragma warning(disable: 4324) // structure was padded due to __declspec(align())
	47	+# pragma warning(disable: 4702) // unreachable code
	48	+# pragma warning(disable: 4996) // this function or variable may be unsafe
	49	+#endif
	50	+
	51	+#if defined(_MSC_VER) && defined(__c2__)
	52	+# pragma clang diagnostic push
	53	+# pragma clang diagnostic ignored "-Wdeprecated" // this function or variable may be unsafe
	54	+#endif
	55	+
	56	+#ifdef __INTEL_COMPILER
	57	+# pragma warning(disable: 177) // function was declared but never referenced
	58	+# pragma warning(disable: 279) // controlling expression is constant
	59	+# pragma warning(disable: 1478 1786) // function was declared "deprecated"
	60	+# pragma warning(disable: 1684) // conversion from pointer to same-sized integral type
	61	+#endif
	62	+
	63	+#if defined(__BORLANDC__) && defined(PUGIXML_HEADER_ONLY)
	64	+# pragma warn -8080 // symbol is declared but never used; disabling this inside push/pop bracket does not make the warning go away
	65	+#endif
	66	+
	67	+#ifdef __BORLANDC__
	68	+# pragma option push
	69	+# pragma warn -8008 // condition is always false
	70	+# pragma warn -8066 // unreachable code
	71	+#endif
	72	+
	73	+#ifdef __SNC__
	74	+// Using diag_push/diag_pop does not disable the warnings inside templates due to a compiler bug
	75	+# pragma diag_suppress=178 // function was declared but never referenced
	76	+# pragma diag_suppress=237 // controlling expression is constant
	77	+#endif
	78	+
	79	+#ifdef __TI_COMPILER_VERSION__
	80	+# pragma diag_suppress 179 // function was declared but never referenced
	81	+#endif
	82	+
	83	+// Inlining controls
	84	+#if defined(_MSC_VER) && _MSC_VER >= 1300
	85	+# define PUGI__NO_INLINE __declspec(noinline)
	86	+#elif defined(__GNUC__)
	87	+# define PUGI__NO_INLINE __attribute__((noinline))
	88	+#else
	89	+# define PUGI__NO_INLINE
	90	+#endif
	91	+
	92	+// Branch weight controls
	93	+#if defined(__GNUC__) && !defined(__c2__)
	94	+# define PUGI__UNLIKELY(cond) __builtin_expect(cond, 0)
	95	+#else
	96	+# define PUGI__UNLIKELY(cond) (cond)
	97	+#endif
	98	+
	99	+// Simple static assertion
	100	+#define PUGI__STATIC_ASSERT(cond) { static const char condition_failed[(cond) ? 1 : -1] = {0}; (void)condition_failed[0]; }
	101	+
	102	+// Digital Mars C++ bug workaround for passing char loaded from memory via stack
	103	+#ifdef __DMC__
	104	+# define PUGI__DMC_VOLATILE volatile
	105	+#else
	106	+# define PUGI__DMC_VOLATILE
	107	+#endif
	108	+
	109	+// Integer sanitizer workaround; we only apply this for clang since gcc8 has no_sanitize but not unsigned-integer-overflow and produces "attribute directive ignored" warnings
	110	+#if defined(__clang__) && defined(__has_attribute)
	111	+# if __has_attribute(no_sanitize)
	112	+# define PUGI__UNSIGNED_OVERFLOW __attribute__((no_sanitize("unsigned-integer-overflow")))
	113	+# else
	114	+# define PUGI__UNSIGNED_OVERFLOW
	115	+# endif
	116	+#else
	117	+# define PUGI__UNSIGNED_OVERFLOW
	118	+#endif
	119	+
	120	+// Borland C++ bug workaround for not defining ::memcpy depending on header include order (can't always use std::memcpy because some compilers don't have it at all)
	121	+#if defined(__BORLANDC__) && !defined(__MEM_H_USING_LIST)
	122	+using std::memcpy;
	123	+using std::memmove;
	124	+using std::memset;
	125	+#endif
	126	+
	127	+// Some MinGW/GCC versions have headers that erroneously omit LLONG_MIN/LLONG_MAX/ULLONG_MAX definitions from limits.h in some configurations
	128	+#if defined(PUGIXML_HAS_LONG_LONG) && defined(__GNUC__) && !defined(LLONG_MAX) && !defined(LLONG_MIN) && !defined(ULLONG_MAX)
	129	+# define LLONG_MIN (-LLONG_MAX - 1LL)
	130	+# define LLONG_MAX __LONG_LONG_MAX__
	131	+# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
	132	+#endif
	133	+
	134	+// In some environments MSVC is a compiler but the CRT lacks certain MSVC-specific features
	135	+#if defined(_MSC_VER) && !defined(__S3E__)
	136	+# define PUGI__MSVC_CRT_VERSION _MSC_VER
	137	+#endif
	138	+
	139	+// Not all platforms have snprintf; we define a wrapper that uses snprintf if possible. This only works with buffers with a known size.
	140	+#if __cplusplus >= 201103
	141	+# define PUGI__SNPRINTF(buf, ...) snprintf(buf, sizeof(buf), __VA_ARGS__)
	142	+#elif defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400
	143	+# define PUGI__SNPRINTF(buf, ...) _snprintf_s(buf, _countof(buf), _TRUNCATE, __VA_ARGS__)
	144	+#else
	145	+# define PUGI__SNPRINTF sprintf
	146	+#endif
	147	+
	148	+// We put implementation details into an anonymous namespace in source mode, but have to keep it in non-anonymous namespace in header-only mode to prevent binary bloat.
	149	+#ifdef PUGIXML_HEADER_ONLY
	150	+# define PUGI__NS_BEGIN namespace pugi { namespace impl {
	151	+# define PUGI__NS_END } }
	152	+# define PUGI__FN inline
	153	+# define PUGI__FN_NO_INLINE inline
	154	+#else
	155	+# if defined(_MSC_VER) && _MSC_VER < 1300 // MSVC6 seems to have an amusing bug with anonymous namespaces inside namespaces
	156	+# define PUGI__NS_BEGIN namespace pugi { namespace impl {
	157	+# define PUGI__NS_END } }
	158	+# else
	159	+# define PUGI__NS_BEGIN namespace pugi { namespace impl { namespace {
	160	+# define PUGI__NS_END } } }
	161	+# endif
	162	+# define PUGI__FN
	163	+# define PUGI__FN_NO_INLINE PUGI__NO_INLINE
	164	+#endif
	165	+
	166	+// uintptr_t
	167	+#if (defined(_MSC_VER) && _MSC_VER < 1600) \|\| (defined(__BORLANDC__) && __BORLANDC__ < 0x561)
	168	+namespace pugi
	169	+{
	170	+# ifndef _UINTPTR_T_DEFINED
	171	+ typedef size_t uintptr_t;
	172	+# endif
	173	+
	174	+ typedef unsigned __int8 uint8_t;
	175	+ typedef unsigned __int16 uint16_t;
	176	+ typedef unsigned __int32 uint32_t;
	177	+}
	178	+#else
	179	+# include <stdint.h>
	180	+#endif
	181	+
	182	+// Memory allocation
	183	+PUGI__NS_BEGIN
	184	+ PUGI__FN void* default_allocate(size_t size)
	185	+ {
	186	+ return malloc(size);
	187	+ }
	188	+
	189	+ PUGI__FN void default_deallocate(void* ptr)
	190	+ {
	191	+ free(ptr);
	192	+ }
	193	+
	194	+ template <typename T>
	195	+ struct xml_memory_management_function_storage
	196	+ {
	197	+ static allocation_function allocate;
	198	+ static deallocation_function deallocate;
	199	+ };
	200	+
	201	+ // Global allocation functions are stored in class statics so that in header mode linker deduplicates them
	202	+ // Without a template<> we'll get multiple definitions of the same static
	203	+ template <typename T> allocation_function xml_memory_management_function_storage<T>::allocate = default_allocate;
	204	+ template <typename T> deallocation_function xml_memory_management_function_storage<T>::deallocate = default_deallocate;
	205	+
	206	+ typedef xml_memory_management_function_storage<int> xml_memory;
	207	+PUGI__NS_END
	208	+
	209	+// String utilities
	210	+PUGI__NS_BEGIN
	211	+ // Get string length
	212	+ PUGI__FN size_t strlength(const char_t* s)
	213	+ {
	214	+ assert(s);
	215	+
	216	+ #ifdef PUGIXML_WCHAR_MODE
	217	+ return wcslen(s);
	218	+ #else
	219	+ return strlen(s);
	220	+ #endif
	221	+ }
	222	+
	223	+ // Compare two strings
	224	+ PUGI__FN bool strequal(const char_t* src, const char_t* dst)
	225	+ {
	226	+ assert(src && dst);
	227	+
	228	+ #ifdef PUGIXML_WCHAR_MODE
	229	+ return wcscmp(src, dst) == 0;
	230	+ #else
	231	+ return strcmp(src, dst) == 0;
	232	+ #endif
	233	+ }
	234	+
	235	+ // Compare lhs with [rhs_begin, rhs_end)
	236	+ PUGI__FN bool strequalrange(const char_t* lhs, const char_t* rhs, size_t count)
	237	+ {
	238	+ for (size_t i = 0; i < count; ++i)
	239	+ if (lhs[i] != rhs[i])
	240	+ return false;
	241	+
	242	+ return lhs[count] == 0;
	243	+ }
	244	+
	245	+ // Get length of wide string, even if CRT lacks wide character support
	246	+ PUGI__FN size_t strlength_wide(const wchar_t* s)
	247	+ {
	248	+ assert(s);
	249	+
	250	+ #ifdef PUGIXML_WCHAR_MODE
	251	+ return wcslen(s);
	252	+ #else
	253	+ const wchar_t* end = s;
	254	+ while (*end) end++;
	255	+ return static_cast<size_t>(end - s);
	256	+ #endif
	257	+ }
	258	+PUGI__NS_END
	259	+
	260	+// auto_ptr-like object for exception recovery
	261	+PUGI__NS_BEGIN
	262	+ template <typename T> struct auto_deleter
	263	+ {
	264	+ typedef void (D)(T);
	265	+
	266	+ T* data;
	267	+ D deleter;
	268	+
	269	+ auto_deleter(T* data_, D deleter_): data(data_), deleter(deleter_)
	270	+ {
	271	+ }
	272	+
	273	+ ~auto_deleter()
	274	+ {
	275	+ if (data) deleter(data);
	276	+ }
	277	+
	278	+ T* release()
	279	+ {
	280	+ T* result = data;
	281	+ data = 0;
	282	+ return result;
	283	+ }
	284	+ };
	285	+PUGI__NS_END
	286	+
	287	+#ifdef PUGIXML_COMPACT
	288	+PUGI__NS_BEGIN
	289	+ class compact_hash_table
	290	+ {
	291	+ public:
	292	+ compact_hash_table(): _items(0), _capacity(0), _count(0)
	293	+ {
	294	+ }
	295	+
	296	+ void clear()
	297	+ {
	298	+ if (_items)
	299	+ {
	300	+ xml_memory::deallocate(_items);
	301	+ _items = 0;
	302	+ _capacity = 0;
	303	+ _count = 0;
	304	+ }
	305	+ }
	306	+
	307	+ void* find(const void* key)
	308	+ {
	309	+ if (_capacity == 0) return 0;
	310	+
	311	+ item_t* item = get_item(key);
	312	+ assert(item);
	313	+ assert(item->key == key \|\| (item->key == 0 && item->value == 0));
	314	+
	315	+ return item->value;
	316	+ }
	317	+
	318	+ void insert(const void* key, void* value)
	319	+ {
	320	+ assert(_capacity != 0 && _count < _capacity - _capacity / 4);
	321	+
	322	+ item_t* item = get_item(key);
	323	+ assert(item);
	324	+
	325	+ if (item->key == 0)
	326	+ {
	327	+ _count++;
	328	+ item->key = key;
	329	+ }
	330	+
	331	+ item->value = value;
	332	+ }
	333	+
	334	+ bool reserve(size_t extra = 16)
	335	+ {
	336	+ if (_count + extra >= _capacity - _capacity / 4)
	337	+ return rehash(_count + extra);
	338	+
	339	+ return true;
	340	+ }
	341	+
	342	+ private:
	343	+ struct item_t
	344	+ {
	345	+ const void* key;
	346	+ void* value;
	347	+ };
	348	+
	349	+ item_t* _items;
	350	+ size_t _capacity;
	351	+
	352	+ size_t _count;
	353	+
	354	+ bool rehash(size_t count);
	355	+
	356	+ item_t* get_item(const void* key)
	357	+ {
	358	+ assert(key);
	359	+ assert(_capacity > 0);
	360	+
	361	+ size_t hashmod = _capacity - 1;
	362	+ size_t bucket = hash(key) & hashmod;
	363	+
	364	+ for (size_t probe = 0; probe <= hashmod; ++probe)
	365	+ {
	366	+ item_t& probe_item = _items[bucket];
	367	+
	368	+ if (probe_item.key == key \|\| probe_item.key == 0)
	369	+ return &probe_item;
	370	+
	371	+ // hash collision, quadratic probing
	372	+ bucket = (bucket + probe + 1) & hashmod;
	373	+ }
	374	+
	375	+ assert(false && "Hash table is full"); // unreachable
	376	+ return 0;
	377	+ }
	378	+
	379	+ static PUGI__UNSIGNED_OVERFLOW unsigned int hash(const void* key)
	380	+ {
	381	+ unsigned int h = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(key) & 0xffffffff);
	382	+
	383	+ // MurmurHash3 32-bit finalizer
	384	+ h ^= h >> 16;
	385	+ h *= 0x85ebca6bu;
	386	+ h ^= h >> 13;
	387	+ h *= 0xc2b2ae35u;
	388	+ h ^= h >> 16;
	389	+
	390	+ return h;
	391	+ }
	392	+ };
	393	+
	394	+ PUGI__FN_NO_INLINE bool compact_hash_table::rehash(size_t count)
	395	+ {
	396	+ size_t capacity = 32;
	397	+ while (count >= capacity - capacity / 4)
	398	+ capacity *= 2;
	399	+
	400	+ compact_hash_table rt;
	401	+ rt._capacity = capacity;
	402	+ rt._items = static_cast<item_t>(xml_memory::allocate(sizeof(item_t) capacity));
	403	+
	404	+ if (!rt._items)
	405	+ return false;
	406	+
	407	+ memset(rt._items, 0, sizeof(item_t) * capacity);
	408	+
	409	+ for (size_t i = 0; i < _capacity; ++i)
	410	+ if (_items[i].key)
	411	+ rt.insert(_items[i].key, _items[i].value);
	412	+
	413	+ if (_items)
	414	+ xml_memory::deallocate(_items);
	415	+
	416	+ _capacity = capacity;
	417	+ _items = rt._items;
	418	+
	419	+ assert(_count == rt._count);
	420	+
	421	+ return true;
	422	+ }
	423	+
	424	+PUGI__NS_END
	425	+#endif
	426	+
	427	+PUGI__NS_BEGIN
	428	+#ifdef PUGIXML_COMPACT
	429	+ static const uintptr_t xml_memory_block_alignment = 4;
	430	+#else
	431	+ static const uintptr_t xml_memory_block_alignment = sizeof(void*);
	432	+#endif
	433	+
	434	+ // extra metadata bits
	435	+ static const uintptr_t xml_memory_page_contents_shared_mask = 64;
	436	+ static const uintptr_t xml_memory_page_name_allocated_mask = 32;
	437	+ static const uintptr_t xml_memory_page_value_allocated_mask = 16;
	438	+ static const uintptr_t xml_memory_page_type_mask = 15;
	439	+
	440	+ // combined masks for string uniqueness
	441	+ static const uintptr_t xml_memory_page_name_allocated_or_shared_mask = xml_memory_page_name_allocated_mask \| xml_memory_page_contents_shared_mask;
	442	+ static const uintptr_t xml_memory_page_value_allocated_or_shared_mask = xml_memory_page_value_allocated_mask \| xml_memory_page_contents_shared_mask;
	443	+
	444	+#ifdef PUGIXML_COMPACT
	445	+ #define PUGI__GETHEADER_IMPL(object, page, flags) // unused
	446	+ #define PUGI__GETPAGE_IMPL(header) (header).get_page()
	447	+#else
	448	+ #define PUGI__GETHEADER_IMPL(object, page, flags) (((reinterpret_cast<char>(object) - reinterpret_cast<char>(page)) << 8) \| (flags))
	449	+ // this macro casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
	450	+ #define PUGI__GETPAGE_IMPL(header) static_cast<impl::xml_memory_page>(const_cast<void>(static_cast<const void>(reinterpret_cast<const char>(&header) - (header >> 8))))
	451	+#endif
	452	+
	453	+ #define PUGI__GETPAGE(n) PUGI__GETPAGE_IMPL((n)->header)
	454	+ #define PUGI__NODETYPE(n) static_cast<xml_node_type>((n)->header & impl::xml_memory_page_type_mask)
	455	+
	456	+ struct xml_allocator;
	457	+
	458	+ struct xml_memory_page
	459	+ {
	460	+ static xml_memory_page* construct(void* memory)
	461	+ {
	462	+ xml_memory_page* result = static_cast<xml_memory_page*>(memory);
	463	+
	464	+ result->allocator = 0;
	465	+ result->prev = 0;
	466	+ result->next = 0;
	467	+ result->busy_size = 0;
	468	+ result->freed_size = 0;
	469	+
	470	+ #ifdef PUGIXML_COMPACT
	471	+ result->compact_string_base = 0;
	472	+ result->compact_shared_parent = 0;
	473	+ result->compact_page_marker = 0;
	474	+ #endif
	475	+
	476	+ return result;
	477	+ }
	478	+
	479	+ xml_allocator* allocator;
	480	+
	481	+ xml_memory_page* prev;
	482	+ xml_memory_page* next;
	483	+
	484	+ size_t busy_size;
	485	+ size_t freed_size;
	486	+
	487	+ #ifdef PUGIXML_COMPACT
	488	+ char_t* compact_string_base;
	489	+ void* compact_shared_parent;
	490	+ uint32_t* compact_page_marker;
	491	+ #endif
	492	+ };
	493	+
	494	+ static const size_t xml_memory_page_size =
	495	+ #ifdef PUGIXML_MEMORY_PAGE_SIZE
	496	+ (PUGIXML_MEMORY_PAGE_SIZE)
	497	+ #else
	498	+ 32768
	499	+ #endif
	500	+ - sizeof(xml_memory_page);
	501	+
	502	+ struct xml_memory_string_header
	503	+ {
	504	+ uint16_t page_offset; // offset from page->data
	505	+ uint16_t full_size; // 0 if string occupies whole page
	506	+ };
	507	+
	508	+ struct xml_allocator
	509	+ {
	510	+ xml_allocator(xml_memory_page* root): _root(root), _busy_size(root->busy_size)
	511	+ {
	512	+ #ifdef PUGIXML_COMPACT
	513	+ _hash = 0;
	514	+ #endif
	515	+ }
	516	+
	517	+ xml_memory_page* allocate_page(size_t data_size)
	518	+ {
	519	+ size_t size = sizeof(xml_memory_page) + data_size;
	520	+
	521	+ // allocate block with some alignment, leaving memory for worst-case padding
	522	+ void* memory = xml_memory::allocate(size);
	523	+ if (!memory) return 0;
	524	+
	525	+ // prepare page structure
	526	+ xml_memory_page* page = xml_memory_page::construct(memory);
	527	+ assert(page);
	528	+
	529	+ page->allocator = _root->allocator;
	530	+
	531	+ return page;
	532	+ }
	533	+
	534	+ static void deallocate_page(xml_memory_page* page)
	535	+ {
	536	+ xml_memory::deallocate(page);
	537	+ }
	538	+
	539	+ void* allocate_memory_oob(size_t size, xml_memory_page*& out_page);
	540	+
	541	+ void* allocate_memory(size_t size, xml_memory_page*& out_page)
	542	+ {
	543	+ if (PUGI__UNLIKELY(_busy_size + size > xml_memory_page_size))
	544	+ return allocate_memory_oob(size, out_page);
	545	+
	546	+ void* buf = reinterpret_cast<char*>(_root) + sizeof(xml_memory_page) + _busy_size;
	547	+
	548	+ _busy_size += size;
	549	+
	550	+ out_page = _root;
	551	+
	552	+ return buf;
	553	+ }
	554	+
	555	+ #ifdef PUGIXML_COMPACT
	556	+ void* allocate_object(size_t size, xml_memory_page*& out_page)
	557	+ {
	558	+ void* result = allocate_memory(size + sizeof(uint32_t), out_page);
	559	+ if (!result) return 0;
	560	+
	561	+ // adjust for marker
	562	+ ptrdiff_t offset = static_cast<char>(result) - reinterpret_cast<char>(out_page->compact_page_marker);
	563	+
	564	+ if (PUGI__UNLIKELY(static_cast<uintptr_t>(offset) >= 256 * xml_memory_block_alignment))
	565	+ {
	566	+ // insert new marker
	567	+ uint32_t* marker = static_cast<uint32_t*>(result);
	568	+
	569	+ marker = static_cast<uint32_t>(reinterpret_cast<char>(marker) - reinterpret_cast<char*>(out_page));
	570	+ out_page->compact_page_marker = marker;
	571	+
	572	+ // since we don't reuse the page space until we reallocate it, we can just pretend that we freed the marker block
	573	+ // this will make sure deallocate_memory correctly tracks the size
	574	+ out_page->freed_size += sizeof(uint32_t);
	575	+
	576	+ return marker + 1;
	577	+ }
	578	+ else
	579	+ {
	580	+ // roll back uint32_t part
	581	+ _busy_size -= sizeof(uint32_t);
	582	+
	583	+ return result;
	584	+ }
	585	+ }
	586	+ #else
	587	+ void* allocate_object(size_t size, xml_memory_page*& out_page)
	588	+ {
	589	+ return allocate_memory(size, out_page);
	590	+ }
	591	+ #endif
	592	+
	593	+ void deallocate_memory(void* ptr, size_t size, xml_memory_page* page)
	594	+ {
	595	+ if (page == _root) page->busy_size = _busy_size;
	596	+
	597	+ assert(ptr >= reinterpret_cast<char>(page) + sizeof(xml_memory_page) && ptr < reinterpret_cast<char>(page) + sizeof(xml_memory_page) + page->busy_size);
	598	+ (void)!ptr;
	599	+
	600	+ page->freed_size += size;
	601	+ assert(page->freed_size <= page->busy_size);
	602	+
	603	+ if (page->freed_size == page->busy_size)
	604	+ {
	605	+ if (page->next == 0)
	606	+ {
	607	+ assert(_root == page);
	608	+
	609	+ // top page freed, just reset sizes
	610	+ page->busy_size = 0;
	611	+ page->freed_size = 0;
	612	+
	613	+ #ifdef PUGIXML_COMPACT
	614	+ // reset compact state to maximize efficiency
	615	+ page->compact_string_base = 0;
	616	+ page->compact_shared_parent = 0;
	617	+ page->compact_page_marker = 0;
	618	+ #endif
	619	+
	620	+ _busy_size = 0;
	621	+ }
	622	+ else
	623	+ {
	624	+ assert(_root != page);
	625	+ assert(page->prev);
	626	+
	627	+ // remove from the list
	628	+ page->prev->next = page->next;
	629	+ page->next->prev = page->prev;
	630	+
	631	+ // deallocate
	632	+ deallocate_page(page);
	633	+ }
	634	+ }
	635	+ }
	636	+
	637	+ char_t* allocate_string(size_t length)
	638	+ {
	639	+ static const size_t max_encoded_offset = (1 << 16) * xml_memory_block_alignment;
	640	+
	641	+ PUGI__STATIC_ASSERT(xml_memory_page_size <= max_encoded_offset);
	642	+
	643	+ // allocate memory for string and header block
	644	+ size_t size = sizeof(xml_memory_string_header) + length * sizeof(char_t);
	645	+
	646	+ // round size up to block alignment boundary
	647	+ size_t full_size = (size + (xml_memory_block_alignment - 1)) & ~(xml_memory_block_alignment - 1);
	648	+
	649	+ xml_memory_page* page;
	650	+ xml_memory_string_header* header = static_cast<xml_memory_string_header*>(allocate_memory(full_size, page));
	651	+
	652	+ if (!header) return 0;
	653	+
	654	+ // setup header
	655	+ ptrdiff_t page_offset = reinterpret_cast<char>(header) - reinterpret_cast<char>(page) - sizeof(xml_memory_page);
	656	+
	657	+ assert(page_offset % xml_memory_block_alignment == 0);
	658	+ assert(page_offset >= 0 && static_cast<size_t>(page_offset) < max_encoded_offset);
	659	+ header->page_offset = static_cast<uint16_t>(static_cast<size_t>(page_offset) / xml_memory_block_alignment);
	660	+
	661	+ // full_size == 0 for large strings that occupy the whole page
	662	+ assert(full_size % xml_memory_block_alignment == 0);
	663	+ assert(full_size < max_encoded_offset \|\| (page->busy_size == full_size && page_offset == 0));
	664	+ header->full_size = static_cast<uint16_t>(full_size < max_encoded_offset ? full_size / xml_memory_block_alignment : 0);
	665	+
	666	+ // round-trip through void* to avoid 'cast increases required alignment of target type' warning
	667	+ // header is guaranteed a pointer-sized alignment, which should be enough for char_t
	668	+ return static_cast<char_t>(static_cast<void>(header + 1));
	669	+ }
	670	+
	671	+ void deallocate_string(char_t* string)
	672	+ {
	673	+ // this function casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
	674	+ // we're guaranteed the proper (pointer-sized) alignment on the input string if it was allocated via allocate_string
	675	+
	676	+ // get header
	677	+ xml_memory_string_header* header = static_cast<xml_memory_string_header>(static_cast<void>(string)) - 1;
	678	+ assert(header);
	679	+
	680	+ // deallocate
	681	+ size_t page_offset = sizeof(xml_memory_page) + header->page_offset * xml_memory_block_alignment;
	682	+ xml_memory_page* page = reinterpret_cast<xml_memory_page>(static_cast<void>(reinterpret_cast<char*>(header) - page_offset));
	683	+
	684	+ // if full_size == 0 then this string occupies the whole page
	685	+ size_t full_size = header->full_size == 0 ? page->busy_size : header->full_size * xml_memory_block_alignment;
	686	+
	687	+ deallocate_memory(header, full_size, page);
	688	+ }
	689	+
	690	+ bool reserve()
	691	+ {
	692	+ #ifdef PUGIXML_COMPACT
	693	+ return _hash->reserve();
	694	+ #else
	695	+ return true;
	696	+ #endif
	697	+ }
	698	+
	699	+ xml_memory_page* _root;
	700	+ size_t _busy_size;
	701	+
	702	+ #ifdef PUGIXML_COMPACT
	703	+ compact_hash_table* _hash;
	704	+ #endif
	705	+ };
	706	+
	707	+ PUGI__FN_NO_INLINE void* xml_allocator::allocate_memory_oob(size_t size, xml_memory_page*& out_page)
	708	+ {
	709	+ const size_t large_allocation_threshold = xml_memory_page_size / 4;
	710	+
	711	+ xml_memory_page* page = allocate_page(size <= large_allocation_threshold ? xml_memory_page_size : size);
	712	+ out_page = page;
	713	+
	714	+ if (!page) return 0;
	715	+
	716	+ if (size <= large_allocation_threshold)
	717	+ {
	718	+ _root->busy_size = _busy_size;
	719	+
	720	+ // insert page at the end of linked list
	721	+ page->prev = _root;
	722	+ _root->next = page;
	723	+ _root = page;
	724	+
	725	+ _busy_size = size;
	726	+ }
	727	+ else
	728	+ {
	729	+ // insert page before the end of linked list, so that it is deleted as soon as possible
	730	+ // the last page is not deleted even if it's empty (see deallocate_memory)
	731	+ assert(_root->prev);
	732	+
	733	+ page->prev = _root->prev;
	734	+ page->next = _root;
	735	+
	736	+ _root->prev->next = page;
	737	+ _root->prev = page;
	738	+
	739	+ page->busy_size = size;
	740	+ }
	741	+
	742	+ return reinterpret_cast<char*>(page) + sizeof(xml_memory_page);
	743	+ }
	744	+PUGI__NS_END
	745	+
	746	+#ifdef PUGIXML_COMPACT
	747	+PUGI__NS_BEGIN
	748	+ static const uintptr_t compact_alignment_log2 = 2;
	749	+ static const uintptr_t compact_alignment = 1 << compact_alignment_log2;
	750	+
	751	+ class compact_header
	752	+ {
	753	+ public:
	754	+ compact_header(xml_memory_page* page, unsigned int flags)
	755	+ {
	756	+ PUGI__STATIC_ASSERT(xml_memory_block_alignment == compact_alignment);
	757	+
	758	+ ptrdiff_t offset = (reinterpret_cast<char>(this) - reinterpret_cast<char>(page->compact_page_marker));
	759	+ assert(offset % compact_alignment == 0 && static_cast<uintptr_t>(offset) < 256 * compact_alignment);
	760	+
	761	+ _page = static_cast<unsigned char>(offset >> compact_alignment_log2);
	762	+ _flags = static_cast<unsigned char>(flags);
	763	+ }
	764	+
	765	+ void operator&=(uintptr_t mod)
	766	+ {
	767	+ _flags &= static_cast<unsigned char>(mod);
	768	+ }
	769	+
	770	+ void operator\|=(uintptr_t mod)
	771	+ {
	772	+ _flags \|= static_cast<unsigned char>(mod);
	773	+ }
	774	+
	775	+ uintptr_t operator&(uintptr_t mod) const
	776	+ {
	777	+ return _flags & mod;
	778	+ }
	779	+
	780	+ xml_memory_page* get_page() const
	781	+ {
	782	+ // round-trip through void* to silence 'cast increases required alignment of target type' warnings
	783	+ const char* page_marker = reinterpret_cast<const char*>(this) - (_page << compact_alignment_log2);
	784	+ const char* page = page_marker - reinterpret_cast<const uint32_t>(static_cast<const void*>(page_marker));
	785	+
	786	+ return const_cast<xml_memory_page>(reinterpret_cast<const xml_memory_page>(static_cast<const void*>(page)));
	787	+ }
	788	+
	789	+ private:
	790	+ unsigned char _page;
	791	+ unsigned char _flags;
	792	+ };
	793	+
	794	+ PUGI__FN xml_memory_page* compact_get_page(const void* object, int header_offset)
	795	+ {
	796	+ const compact_header* header = reinterpret_cast<const compact_header>(static_cast<const char>(object) - header_offset);
	797	+
	798	+ return header->get_page();
	799	+ }
	800	+
	801	+ template <int header_offset, typename T> PUGI__FN_NO_INLINE T* compact_get_value(const void* object)
	802	+ {
	803	+ return static_cast<T*>(compact_get_page(object, header_offset)->allocator->_hash->find(object));
	804	+ }
	805	+
	806	+ template <int header_offset, typename T> PUGI__FN_NO_INLINE void compact_set_value(const void* object, T* value)
	807	+ {
	808	+ compact_get_page(object, header_offset)->allocator->_hash->insert(object, value);
	809	+ }
	810	+
	811	+ template <typename T, int header_offset, int start = -126> class compact_pointer
	812	+ {
	813	+ public:
	814	+ compact_pointer(): _data(0)
	815	+ {
	816	+ }
	817	+
	818	+ void operator=(const compact_pointer& rhs)
	819	+ {
	820	+ *this = rhs + 0;
	821	+ }
	822	+
	823	+ void operator=(T* value)
	824	+ {
	825	+ if (value)
	826	+ {
	827	+ // value is guaranteed to be compact-aligned; 'this' is not
	828	+ // our decoding is based on 'this' aligned to compact alignment downwards (see operator T*)
	829	+ // so for negative offsets (e.g. -3) we need to adjust the diff by compact_alignment - 1 to
	830	+ // compensate for arithmetic shift rounding for negative values
	831	+ ptrdiff_t diff = reinterpret_cast<char>(value) - reinterpret_cast<char>(this);
	832	+ ptrdiff_t offset = ((diff + int(compact_alignment - 1)) >> compact_alignment_log2) - start;
	833	+
	834	+ if (static_cast<uintptr_t>(offset) <= 253)
	835	+ _data = static_cast<unsigned char>(offset + 1);
	836	+ else
	837	+ {
	838	+ compact_set_value<header_offset>(this, value);
	839	+
	840	+ _data = 255;
	841	+ }
	842	+ }
	843	+ else
	844	+ _data = 0;
	845	+ }
	846	+
	847	+ operator T*() const
	848	+ {
	849	+ if (_data)
	850	+ {
	851	+ if (_data < 255)
	852	+ {
	853	+ uintptr_t base = reinterpret_cast<uintptr_t>(this) & ~(compact_alignment - 1);
	854	+
	855	+ return reinterpret_cast<T>(base + (_data - 1 + start) compact_alignment);
	856	+ }
	857	+ else
	858	+ return compact_get_value<header_offset, T>(this);
	859	+ }
	860	+ else
	861	+ return 0;
	862	+ }
	863	+
	864	+ T* operator->() const
	865	+ {
	866	+ return *this;
	867	+ }
	868	+
	869	+ private:
	870	+ unsigned char _data;
	871	+ };
	872	+
	873	+ template <typename T, int header_offset> class compact_pointer_parent
	874	+ {
	875	+ public:
	876	+ compact_pointer_parent(): _data(0)
	877	+ {
	878	+ }
	879	+
	880	+ void operator=(const compact_pointer_parent& rhs)
	881	+ {
	882	+ *this = rhs + 0;
	883	+ }
	884	+
	885	+ void operator=(T* value)
	886	+ {
	887	+ if (value)
	888	+ {
	889	+ // value is guaranteed to be compact-aligned; 'this' is not
	890	+ // our decoding is based on 'this' aligned to compact alignment downwards (see operator T*)
	891	+ // so for negative offsets (e.g. -3) we need to adjust the diff by compact_alignment - 1 to
	892	+ // compensate for arithmetic shift behavior for negative values
	893	+ ptrdiff_t diff = reinterpret_cast<char>(value) - reinterpret_cast<char>(this);
	894	+ ptrdiff_t offset = ((diff + int(compact_alignment - 1)) >> compact_alignment_log2) + 65533;
	895	+
	896	+ if (static_cast<uintptr_t>(offset) <= 65533)
	897	+ {
	898	+ _data = static_cast<unsigned short>(offset + 1);
	899	+ }
	900	+ else
	901	+ {
	902	+ xml_memory_page* page = compact_get_page(this, header_offset);
	903	+
	904	+ if (PUGI__UNLIKELY(page->compact_shared_parent == 0))
	905	+ page->compact_shared_parent = value;
	906	+
	907	+ if (page->compact_shared_parent == value)
	908	+ {
	909	+ _data = 65534;
	910	+ }
	911	+ else
	912	+ {
	913	+ compact_set_value<header_offset>(this, value);
	914	+
	915	+ _data = 65535;
	916	+ }
	917	+ }
	918	+ }
	919	+ else
	920	+ {
	921	+ _data = 0;
	922	+ }
	923	+ }
	924	+
	925	+ operator T*() const
	926	+ {
	927	+ if (_data)
	928	+ {
	929	+ if (_data < 65534)
	930	+ {
	931	+ uintptr_t base = reinterpret_cast<uintptr_t>(this) & ~(compact_alignment - 1);
	932	+
	933	+ return reinterpret_cast<T>(base + (_data - 1 - 65533) compact_alignment);
	934	+ }
	935	+ else if (_data == 65534)
	936	+ return static_cast<T*>(compact_get_page(this, header_offset)->compact_shared_parent);
	937	+ else
	938	+ return compact_get_value<header_offset, T>(this);
	939	+ }
	940	+ else
	941	+ return 0;
	942	+ }
	943	+
	944	+ T* operator->() const
	945	+ {
	946	+ return *this;
	947	+ }
	948	+
	949	+ private:
	950	+ uint16_t _data;
	951	+ };
	952	+
	953	+ template <int header_offset, int base_offset> class compact_string
	954	+ {
	955	+ public:
	956	+ compact_string(): _data(0)
	957	+ {
	958	+ }
	959	+
	960	+ void operator=(const compact_string& rhs)
	961	+ {
	962	+ *this = rhs + 0;
	963	+ }
	964	+
	965	+ void operator=(char_t* value)
	966	+ {
	967	+ if (value)
	968	+ {
	969	+ xml_memory_page* page = compact_get_page(this, header_offset);
	970	+
	971	+ if (PUGI__UNLIKELY(page->compact_string_base == 0))
	972	+ page->compact_string_base = value;
	973	+
	974	+ ptrdiff_t offset = value - page->compact_string_base;
	975	+
	976	+ if (static_cast<uintptr_t>(offset) < (65535 << 7))
	977	+ {
	978	+ // round-trip through void* to silence 'cast increases required alignment of target type' warnings
	979	+ uint16_t* base = reinterpret_cast<uint16_t>(static_cast<void>(reinterpret_cast<char*>(this) - base_offset));
	980	+
	981	+ if (*base == 0)
	982	+ {
	983	+ *base = static_cast<uint16_t>((offset >> 7) + 1);
	984	+ _data = static_cast<unsigned char>((offset & 127) + 1);
	985	+ }
	986	+ else
	987	+ {
	988	+ ptrdiff_t remainder = offset - ((*base - 1) << 7);
	989	+
	990	+ if (static_cast<uintptr_t>(remainder) <= 253)
	991	+ {
	992	+ _data = static_cast<unsigned char>(remainder + 1);
	993	+ }
	994	+ else
	995	+ {
	996	+ compact_set_value<header_offset>(this, value);
	997	+
	998	+ _data = 255;
	999	+ }
	1000	+ }
	1001	+ }
	1002	+ else
	1003	+ {
	1004	+ compact_set_value<header_offset>(this, value);
	1005	+
	1006	+ _data = 255;
	1007	+ }
	1008	+ }
	1009	+ else
	1010	+ {
	1011	+ _data = 0;
	1012	+ }
	1013	+ }
	1014	+
	1015	+ operator char_t*() const
	1016	+ {
	1017	+ if (_data)
	1018	+ {
	1019	+ if (_data < 255)
	1020	+ {
	1021	+ xml_memory_page* page = compact_get_page(this, header_offset);
	1022	+
	1023	+ // round-trip through void* to silence 'cast increases required alignment of target type' warnings
	1024	+ const uint16_t* base = reinterpret_cast<const uint16_t>(static_cast<const void>(reinterpret_cast<const char*>(this) - base_offset));
	1025	+ assert(*base);
	1026	+
	1027	+ ptrdiff_t offset = ((*base - 1) << 7) + (_data - 1);
	1028	+
	1029	+ return page->compact_string_base + offset;
	1030	+ }
	1031	+ else
	1032	+ {
	1033	+ return compact_get_value<header_offset, char_t>(this);
	1034	+ }
	1035	+ }
	1036	+ else
	1037	+ return 0;
	1038	+ }
	1039	+
	1040	+ private:
	1041	+ unsigned char _data;
	1042	+ };
	1043	+PUGI__NS_END
	1044	+#endif
	1045	+
	1046	+#ifdef PUGIXML_COMPACT
	1047	+namespace pugi
	1048	+{
	1049	+ struct xml_attribute_struct
	1050	+ {
	1051	+ xml_attribute_struct(impl::xml_memory_page* page): header(page, 0), namevalue_base(0)
	1052	+ {
	1053	+ PUGI__STATIC_ASSERT(sizeof(xml_attribute_struct) == 8);
	1054	+ }
	1055	+
	1056	+ impl::compact_header header;
	1057	+
	1058	+ uint16_t namevalue_base;
	1059	+
	1060	+ impl::compact_string<4, 2> name;
	1061	+ impl::compact_string<5, 3> value;
	1062	+
	1063	+ impl::compact_pointer<xml_attribute_struct, 6> prev_attribute_c;
	1064	+ impl::compact_pointer<xml_attribute_struct, 7, 0> next_attribute;
	1065	+ };
	1066	+
	1067	+ struct xml_node_struct
	1068	+ {
	1069	+ xml_node_struct(impl::xml_memory_page* page, xml_node_type type): header(page, type), namevalue_base(0)
	1070	+ {
	1071	+ PUGI__STATIC_ASSERT(sizeof(xml_node_struct) == 12);
	1072	+ }
	1073	+
	1074	+ impl::compact_header header;
	1075	+
	1076	+ uint16_t namevalue_base;
	1077	+
	1078	+ impl::compact_string<4, 2> name;
	1079	+ impl::compact_string<5, 3> value;
	1080	+
	1081	+ impl::compact_pointer_parent<xml_node_struct, 6> parent;
	1082	+
	1083	+ impl::compact_pointer<xml_node_struct, 8, 0> first_child;
	1084	+
	1085	+ impl::compact_pointer<xml_node_struct, 9> prev_sibling_c;
	1086	+ impl::compact_pointer<xml_node_struct, 10, 0> next_sibling;
	1087	+
	1088	+ impl::compact_pointer<xml_attribute_struct, 11, 0> first_attribute;
	1089	+ };
	1090	+}
	1091	+#else
	1092	+namespace pugi
	1093	+{
	1094	+ struct xml_attribute_struct
	1095	+ {
	1096	+ xml_attribute_struct(impl::xml_memory_page* page): name(0), value(0), prev_attribute_c(0), next_attribute(0)
	1097	+ {
	1098	+ header = PUGI__GETHEADER_IMPL(this, page, 0);
	1099	+ }
	1100	+
	1101	+ uintptr_t header;
	1102	+
	1103	+ char_t* name;
	1104	+ char_t* value;
	1105	+
	1106	+ xml_attribute_struct* prev_attribute_c;
	1107	+ xml_attribute_struct* next_attribute;
	1108	+ };
	1109	+
	1110	+ struct xml_node_struct
	1111	+ {
	1112	+ xml_node_struct(impl::xml_memory_page* page, xml_node_type type): name(0), value(0), parent(0), first_child(0), prev_sibling_c(0), next_sibling(0), first_attribute(0)
	1113	+ {
	1114	+ header = PUGI__GETHEADER_IMPL(this, page, type);
	1115	+ }
	1116	+
	1117	+ uintptr_t header;
	1118	+
	1119	+ char_t* name;
	1120	+ char_t* value;
	1121	+
	1122	+ xml_node_struct* parent;
	1123	+
	1124	+ xml_node_struct* first_child;
	1125	+
	1126	+ xml_node_struct* prev_sibling_c;
	1127	+ xml_node_struct* next_sibling;
	1128	+
	1129	+ xml_attribute_struct* first_attribute;
	1130	+ };
	1131	+}
	1132	+#endif
	1133	+
	1134	+PUGI__NS_BEGIN
	1135	+ struct xml_extra_buffer
	1136	+ {
	1137	+ char_t* buffer;
	1138	+ xml_extra_buffer* next;
	1139	+ };
	1140	+
	1141	+ struct xml_document_struct: public xml_node_struct, public xml_allocator
	1142	+ {
	1143	+ xml_document_struct(xml_memory_page* page): xml_node_struct(page, node_document), xml_allocator(page), buffer(0), extra_buffers(0)
	1144	+ {
	1145	+ }
	1146	+
	1147	+ const char_t* buffer;
	1148	+
	1149	+ xml_extra_buffer* extra_buffers;
	1150	+
	1151	+ #ifdef PUGIXML_COMPACT
	1152	+ compact_hash_table hash;
	1153	+ #endif
	1154	+ };
	1155	+
	1156	+ template <typename Object> inline xml_allocator& get_allocator(const Object* object)
	1157	+ {
	1158	+ assert(object);
	1159	+
	1160	+ return *PUGI__GETPAGE(object)->allocator;
	1161	+ }
	1162	+
	1163	+ template <typename Object> inline xml_document_struct& get_document(const Object* object)
	1164	+ {
	1165	+ assert(object);
	1166	+
	1167	+ return static_cast<xml_document_struct>(PUGI__GETPAGE(object)->allocator);
	1168	+ }
	1169	+PUGI__NS_END
	1170	+
	1171	+// Low-level DOM operations
	1172	+PUGI__NS_BEGIN
	1173	+ inline xml_attribute_struct* allocate_attribute(xml_allocator& alloc)
	1174	+ {
	1175	+ xml_memory_page* page;
	1176	+ void* memory = alloc.allocate_object(sizeof(xml_attribute_struct), page);
	1177	+ if (!memory) return 0;
	1178	+
	1179	+ return new (memory) xml_attribute_struct(page);
	1180	+ }
	1181	+
	1182	+ inline xml_node_struct* allocate_node(xml_allocator& alloc, xml_node_type type)
	1183	+ {
	1184	+ xml_memory_page* page;
	1185	+ void* memory = alloc.allocate_object(sizeof(xml_node_struct), page);
	1186	+ if (!memory) return 0;
	1187	+
	1188	+ return new (memory) xml_node_struct(page, type);
	1189	+ }
	1190	+
	1191	+ inline void destroy_attribute(xml_attribute_struct* a, xml_allocator& alloc)
	1192	+ {
	1193	+ if (a->header & impl::xml_memory_page_name_allocated_mask)
	1194	+ alloc.deallocate_string(a->name);
	1195	+
	1196	+ if (a->header & impl::xml_memory_page_value_allocated_mask)
	1197	+ alloc.deallocate_string(a->value);
	1198	+
	1199	+ alloc.deallocate_memory(a, sizeof(xml_attribute_struct), PUGI__GETPAGE(a));
	1200	+ }
	1201	+
	1202	+ inline void destroy_node(xml_node_struct* n, xml_allocator& alloc)
	1203	+ {
	1204	+ if (n->header & impl::xml_memory_page_name_allocated_mask)
	1205	+ alloc.deallocate_string(n->name);
	1206	+
	1207	+ if (n->header & impl::xml_memory_page_value_allocated_mask)
	1208	+ alloc.deallocate_string(n->value);
	1209	+
	1210	+ for (xml_attribute_struct* attr = n->first_attribute; attr; )
	1211	+ {
	1212	+ xml_attribute_struct* next = attr->next_attribute;
	1213	+
	1214	+ destroy_attribute(attr, alloc);
	1215	+
	1216	+ attr = next;
	1217	+ }
	1218	+
	1219	+ for (xml_node_struct* child = n->first_child; child; )
	1220	+ {
	1221	+ xml_node_struct* next = child->next_sibling;
	1222	+
	1223	+ destroy_node(child, alloc);
	1224	+
	1225	+ child = next;
	1226	+ }
	1227	+
	1228	+ alloc.deallocate_memory(n, sizeof(xml_node_struct), PUGI__GETPAGE(n));
	1229	+ }
	1230	+
	1231	+ inline void append_node(xml_node_struct* child, xml_node_struct* node)
	1232	+ {
	1233	+ child->parent = node;
	1234	+
	1235	+ xml_node_struct* head = node->first_child;
	1236	+
	1237	+ if (head)
	1238	+ {
	1239	+ xml_node_struct* tail = head->prev_sibling_c;
	1240	+
	1241	+ tail->next_sibling = child;
	1242	+ child->prev_sibling_c = tail;
	1243	+ head->prev_sibling_c = child;
	1244	+ }
	1245	+ else
	1246	+ {
	1247	+ node->first_child = child;
	1248	+ child->prev_sibling_c = child;
	1249	+ }
	1250	+ }
	1251	+
	1252	+ inline void prepend_node(xml_node_struct* child, xml_node_struct* node)
	1253	+ {
	1254	+ child->parent = node;
	1255	+
	1256	+ xml_node_struct* head = node->first_child;
	1257	+
	1258	+ if (head)
	1259	+ {
	1260	+ child->prev_sibling_c = head->prev_sibling_c;
	1261	+ head->prev_sibling_c = child;
	1262	+ }
	1263	+ else
	1264	+ child->prev_sibling_c = child;
	1265	+
	1266	+ child->next_sibling = head;
	1267	+ node->first_child = child;
	1268	+ }
	1269	+
	1270	+ inline void insert_node_after(xml_node_struct* child, xml_node_struct* node)
	1271	+ {
	1272	+ xml_node_struct* parent = node->parent;
	1273	+
	1274	+ child->parent = parent;
	1275	+
	1276	+ if (node->next_sibling)
	1277	+ node->next_sibling->prev_sibling_c = child;
	1278	+ else
	1279	+ parent->first_child->prev_sibling_c = child;
	1280	+
	1281	+ child->next_sibling = node->next_sibling;
	1282	+ child->prev_sibling_c = node;
	1283	+
	1284	+ node->next_sibling = child;
	1285	+ }
	1286	+
	1287	+ inline void insert_node_before(xml_node_struct* child, xml_node_struct* node)
	1288	+ {
	1289	+ xml_node_struct* parent = node->parent;
	1290	+
	1291	+ child->parent = parent;
	1292	+
	1293	+ if (node->prev_sibling_c->next_sibling)
	1294	+ node->prev_sibling_c->next_sibling = child;
	1295	+ else
	1296	+ parent->first_child = child;
	1297	+
	1298	+ child->prev_sibling_c = node->prev_sibling_c;
	1299	+ child->next_sibling = node;
	1300	+
	1301	+ node->prev_sibling_c = child;
	1302	+ }
	1303	+
	1304	+ inline void remove_node(xml_node_struct* node)
	1305	+ {
	1306	+ xml_node_struct* parent = node->parent;
	1307	+
	1308	+ if (node->next_sibling)
	1309	+ node->next_sibling->prev_sibling_c = node->prev_sibling_c;
	1310	+ else
	1311	+ parent->first_child->prev_sibling_c = node->prev_sibling_c;
	1312	+
	1313	+ if (node->prev_sibling_c->next_sibling)
	1314	+ node->prev_sibling_c->next_sibling = node->next_sibling;
	1315	+ else
	1316	+ parent->first_child = node->next_sibling;
	1317	+
	1318	+ node->parent = 0;
	1319	+ node->prev_sibling_c = 0;
	1320	+ node->next_sibling = 0;
	1321	+ }
	1322	+
	1323	+ inline void append_attribute(xml_attribute_struct* attr, xml_node_struct* node)
	1324	+ {
	1325	+ xml_attribute_struct* head = node->first_attribute;
	1326	+
	1327	+ if (head)
	1328	+ {
	1329	+ xml_attribute_struct* tail = head->prev_attribute_c;
	1330	+
	1331	+ tail->next_attribute = attr;
	1332	+ attr->prev_attribute_c = tail;
	1333	+ head->prev_attribute_c = attr;
	1334	+ }
	1335	+ else
	1336	+ {
	1337	+ node->first_attribute = attr;
	1338	+ attr->prev_attribute_c = attr;
	1339	+ }
	1340	+ }
	1341	+
	1342	+ inline void prepend_attribute(xml_attribute_struct* attr, xml_node_struct* node)
	1343	+ {
	1344	+ xml_attribute_struct* head = node->first_attribute;
	1345	+
	1346	+ if (head)
	1347	+ {
	1348	+ attr->prev_attribute_c = head->prev_attribute_c;
	1349	+ head->prev_attribute_c = attr;
	1350	+ }
	1351	+ else
	1352	+ attr->prev_attribute_c = attr;
	1353	+
	1354	+ attr->next_attribute = head;
	1355	+ node->first_attribute = attr;
	1356	+ }
	1357	+
	1358	+ inline void insert_attribute_after(xml_attribute_struct* attr, xml_attribute_struct* place, xml_node_struct* node)
	1359	+ {
	1360	+ if (place->next_attribute)
	1361	+ place->next_attribute->prev_attribute_c = attr;
	1362	+ else
	1363	+ node->first_attribute->prev_attribute_c = attr;
	1364	+
	1365	+ attr->next_attribute = place->next_attribute;
	1366	+ attr->prev_attribute_c = place;
	1367	+ place->next_attribute = attr;
	1368	+ }
	1369	+
	1370	+ inline void insert_attribute_before(xml_attribute_struct* attr, xml_attribute_struct* place, xml_node_struct* node)
	1371	+ {
	1372	+ if (place->prev_attribute_c->next_attribute)
	1373	+ place->prev_attribute_c->next_attribute = attr;
	1374	+ else
	1375	+ node->first_attribute = attr;
	1376	+
	1377	+ attr->prev_attribute_c = place->prev_attribute_c;
	1378	+ attr->next_attribute = place;
	1379	+ place->prev_attribute_c = attr;
	1380	+ }
	1381	+
	1382	+ inline void remove_attribute(xml_attribute_struct* attr, xml_node_struct* node)
	1383	+ {
	1384	+ if (attr->next_attribute)
	1385	+ attr->next_attribute->prev_attribute_c = attr->prev_attribute_c;
	1386	+ else
	1387	+ node->first_attribute->prev_attribute_c = attr->prev_attribute_c;
	1388	+
	1389	+ if (attr->prev_attribute_c->next_attribute)
	1390	+ attr->prev_attribute_c->next_attribute = attr->next_attribute;
	1391	+ else
	1392	+ node->first_attribute = attr->next_attribute;
	1393	+
	1394	+ attr->prev_attribute_c = 0;
	1395	+ attr->next_attribute = 0;
	1396	+ }
	1397	+
	1398	+ PUGI__FN_NO_INLINE xml_node_struct* append_new_node(xml_node_struct* node, xml_allocator& alloc, xml_node_type type = node_element)
	1399	+ {
	1400	+ if (!alloc.reserve()) return 0;
	1401	+
	1402	+ xml_node_struct* child = allocate_node(alloc, type);
	1403	+ if (!child) return 0;
	1404	+
	1405	+ append_node(child, node);
	1406	+
	1407	+ return child;
	1408	+ }
	1409	+
	1410	+ PUGI__FN_NO_INLINE xml_attribute_struct* append_new_attribute(xml_node_struct* node, xml_allocator& alloc)
	1411	+ {
	1412	+ if (!alloc.reserve()) return 0;
	1413	+
	1414	+ xml_attribute_struct* attr = allocate_attribute(alloc);
	1415	+ if (!attr) return 0;
	1416	+
	1417	+ append_attribute(attr, node);
	1418	+
	1419	+ return attr;
	1420	+ }
	1421	+PUGI__NS_END
	1422	+
	1423	+// Helper classes for code generation
	1424	+PUGI__NS_BEGIN
	1425	+ struct opt_false
	1426	+ {
	1427	+ enum { value = 0 };
	1428	+ };
	1429	+
	1430	+ struct opt_true
	1431	+ {
	1432	+ enum { value = 1 };
	1433	+ };
	1434	+PUGI__NS_END
	1435	+
	1436	+// Unicode utilities
	1437	+PUGI__NS_BEGIN
	1438	+ inline uint16_t endian_swap(uint16_t value)
	1439	+ {
	1440	+ return static_cast<uint16_t>(((value & 0xff) << 8) \| (value >> 8));
	1441	+ }
	1442	+
	1443	+ inline uint32_t endian_swap(uint32_t value)
	1444	+ {
	1445	+ return ((value & 0xff) << 24) \| ((value & 0xff00) << 8) \| ((value & 0xff0000) >> 8) \| (value >> 24);
	1446	+ }
	1447	+
	1448	+ struct utf8_counter
	1449	+ {
	1450	+ typedef size_t value_type;
	1451	+
	1452	+ static value_type low(value_type result, uint32_t ch)
	1453	+ {
	1454	+ // U+0000..U+007F
	1455	+ if (ch < 0x80) return result + 1;
	1456	+ // U+0080..U+07FF
	1457	+ else if (ch < 0x800) return result + 2;
	1458	+ // U+0800..U+FFFF
	1459	+ else return result + 3;
	1460	+ }
	1461	+
	1462	+ static value_type high(value_type result, uint32_t)
	1463	+ {
	1464	+ // U+10000..U+10FFFF
	1465	+ return result + 4;
	1466	+ }
	1467	+ };
	1468	+
	1469	+ struct utf8_writer
	1470	+ {
	1471	+ typedef uint8_t* value_type;
	1472	+
	1473	+ static value_type low(value_type result, uint32_t ch)
	1474	+ {
	1475	+ // U+0000..U+007F
	1476	+ if (ch < 0x80)
	1477	+ {
	1478	+ *result = static_cast<uint8_t>(ch);
	1479	+ return result + 1;
	1480	+ }
	1481	+ // U+0080..U+07FF
	1482	+ else if (ch < 0x800)
	1483	+ {
	1484	+ result[0] = static_cast<uint8_t>(0xC0 \| (ch >> 6));
	1485	+ result[1] = static_cast<uint8_t>(0x80 \| (ch & 0x3F));
	1486	+ return result + 2;
	1487	+ }
	1488	+ // U+0800..U+FFFF
	1489	+ else
	1490	+ {
	1491	+ result[0] = static_cast<uint8_t>(0xE0 \| (ch >> 12));
	1492	+ result[1] = static_cast<uint8_t>(0x80 \| ((ch >> 6) & 0x3F));
	1493	+ result[2] = static_cast<uint8_t>(0x80 \| (ch & 0x3F));
	1494	+ return result + 3;
	1495	+ }
	1496	+ }
	1497	+
	1498	+ static value_type high(value_type result, uint32_t ch)
	1499	+ {
	1500	+ // U+10000..U+10FFFF
	1501	+ result[0] = static_cast<uint8_t>(0xF0 \| (ch >> 18));
	1502	+ result[1] = static_cast<uint8_t>(0x80 \| ((ch >> 12) & 0x3F));
	1503	+ result[2] = static_cast<uint8_t>(0x80 \| ((ch >> 6) & 0x3F));
	1504	+ result[3] = static_cast<uint8_t>(0x80 \| (ch & 0x3F));
	1505	+ return result + 4;
	1506	+ }
	1507	+
	1508	+ static value_type any(value_type result, uint32_t ch)
	1509	+ {
	1510	+ return (ch < 0x10000) ? low(result, ch) : high(result, ch);
	1511	+ }
	1512	+ };
	1513	+
	1514	+ struct utf16_counter
	1515	+ {
	1516	+ typedef size_t value_type;
	1517	+
	1518	+ static value_type low(value_type result, uint32_t)
	1519	+ {
	1520	+ return result + 1;
	1521	+ }
	1522	+
	1523	+ static value_type high(value_type result, uint32_t)
	1524	+ {
	1525	+ return result + 2;
	1526	+ }
	1527	+ };
	1528	+
	1529	+ struct utf16_writer
	1530	+ {
	1531	+ typedef uint16_t* value_type;
	1532	+
	1533	+ static value_type low(value_type result, uint32_t ch)
	1534	+ {
	1535	+ *result = static_cast<uint16_t>(ch);
	1536	+
	1537	+ return result + 1;
	1538	+ }
	1539	+
	1540	+ static value_type high(value_type result, uint32_t ch)
	1541	+ {
	1542	+ uint32_t msh = static_cast<uint32_t>(ch - 0x10000) >> 10;
	1543	+ uint32_t lsh = static_cast<uint32_t>(ch - 0x10000) & 0x3ff;
	1544	+
	1545	+ result[0] = static_cast<uint16_t>(0xD800 + msh);
	1546	+ result[1] = static_cast<uint16_t>(0xDC00 + lsh);
	1547	+
	1548	+ return result + 2;
	1549	+ }
	1550	+
	1551	+ static value_type any(value_type result, uint32_t ch)
	1552	+ {
	1553	+ return (ch < 0x10000) ? low(result, ch) : high(result, ch);
	1554	+ }
	1555	+ };
	1556	+
	1557	+ struct utf32_counter
	1558	+ {
	1559	+ typedef size_t value_type;
	1560	+
	1561	+ static value_type low(value_type result, uint32_t)
	1562	+ {
	1563	+ return result + 1;
	1564	+ }
	1565	+
	1566	+ static value_type high(value_type result, uint32_t)
	1567	+ {
	1568	+ return result + 1;
	1569	+ }
	1570	+ };
	1571	+
	1572	+ struct utf32_writer
	1573	+ {
	1574	+ typedef uint32_t* value_type;
	1575	+
	1576	+ static value_type low(value_type result, uint32_t ch)
	1577	+ {
	1578	+ *result = ch;
	1579	+
	1580	+ return result + 1;
	1581	+ }
	1582	+
	1583	+ static value_type high(value_type result, uint32_t ch)
	1584	+ {
	1585	+ *result = ch;
	1586	+
	1587	+ return result + 1;
	1588	+ }
	1589	+
	1590	+ static value_type any(value_type result, uint32_t ch)
	1591	+ {
	1592	+ *result = ch;
	1593	+
	1594	+ return result + 1;
	1595	+ }
	1596	+ };
	1597	+
	1598	+ struct latin1_writer
	1599	+ {
	1600	+ typedef uint8_t* value_type;
	1601	+
	1602	+ static value_type low(value_type result, uint32_t ch)
	1603	+ {
	1604	+ *result = static_cast<uint8_t>(ch > 255 ? '?' : ch);
	1605	+
	1606	+ return result + 1;
	1607	+ }
	1608	+
	1609	+ static value_type high(value_type result, uint32_t ch)
	1610	+ {
	1611	+ (void)ch;
	1612	+
	1613	+ *result = '?';
	1614	+
	1615	+ return result + 1;
	1616	+ }
	1617	+ };
	1618	+
	1619	+ struct utf8_decoder
	1620	+ {
	1621	+ typedef uint8_t type;
	1622	+
	1623	+ template <typename Traits> static inline typename Traits::value_type process(const uint8_t* data, size_t size, typename Traits::value_type result, Traits)
	1624	+ {
	1625	+ const uint8_t utf8_byte_mask = 0x3f;
	1626	+
	1627	+ while (size)
	1628	+ {
	1629	+ uint8_t lead = *data;
	1630	+
	1631	+ // 0xxxxxxx -> U+0000..U+007F
	1632	+ if (lead < 0x80)
	1633	+ {
	1634	+ result = Traits::low(result, lead);
	1635	+ data += 1;
	1636	+ size -= 1;
	1637	+
	1638	+ // process aligned single-byte (ascii) blocks
	1639	+ if ((reinterpret_cast<uintptr_t>(data) & 3) == 0)
	1640	+ {
	1641	+ // round-trip through void* to silence 'cast increases required alignment of target type' warnings
	1642	+ while (size >= 4 && (static_cast<const uint32_t>(static_cast<const void*>(data)) & 0x80808080) == 0)
	1643	+ {
	1644	+ result = Traits::low(result, data[0]);
	1645	+ result = Traits::low(result, data[1]);
	1646	+ result = Traits::low(result, data[2]);
	1647	+ result = Traits::low(result, data[3]);
	1648	+ data += 4;
	1649	+ size -= 4;
	1650	+ }
	1651	+ }
	1652	+ }
	1653	+ // 110xxxxx -> U+0080..U+07FF
	1654	+ else if (static_cast<unsigned int>(lead - 0xC0) < 0x20 && size >= 2 && (data[1] & 0xc0) == 0x80)
	1655	+ {
	1656	+ result = Traits::low(result, ((lead & ~0xC0) << 6) \| (data[1] & utf8_byte_mask));
	1657	+ data += 2;
	1658	+ size -= 2;
	1659	+ }
	1660	+ // 1110xxxx -> U+0800-U+FFFF
	1661	+ else if (static_cast<unsigned int>(lead - 0xE0) < 0x10 && size >= 3 && (data[1] & 0xc0) == 0x80 && (data[2] & 0xc0) == 0x80)
	1662	+ {
	1663	+ result = Traits::low(result, ((lead & ~0xE0) << 12) \| ((data[1] & utf8_byte_mask) << 6) \| (data[2] & utf8_byte_mask));
	1664	+ data += 3;
	1665	+ size -= 3;
	1666	+ }
	1667	+ // 11110xxx -> U+10000..U+10FFFF
	1668	+ else if (static_cast<unsigned int>(lead - 0xF0) < 0x08 && size >= 4 && (data[1] & 0xc0) == 0x80 && (data[2] & 0xc0) == 0x80 && (data[3] & 0xc0) == 0x80)
	1669	+ {
	1670	+ result = Traits::high(result, ((lead & ~0xF0) << 18) \| ((data[1] & utf8_byte_mask) << 12) \| ((data[2] & utf8_byte_mask) << 6) \| (data[3] & utf8_byte_mask));
	1671	+ data += 4;
	1672	+ size -= 4;
	1673	+ }
	1674	+ // 10xxxxxx or 11111xxx -> invalid
	1675	+ else
	1676	+ {
	1677	+ data += 1;
	1678	+ size -= 1;
	1679	+ }
	1680	+ }
	1681	+
	1682	+ return result;
	1683	+ }
	1684	+ };
	1685	+
	1686	+ template <typename opt_swap> struct utf16_decoder
	1687	+ {
	1688	+ typedef uint16_t type;
	1689	+
	1690	+ template <typename Traits> static inline typename Traits::value_type process(const uint16_t* data, size_t size, typename Traits::value_type result, Traits)
	1691	+ {
	1692	+ while (size)
	1693	+ {
	1694	+ uint16_t lead = opt_swap::value ? endian_swap(data) : data;
	1695	+
	1696	+ // U+0000..U+D7FF
	1697	+ if (lead < 0xD800)
	1698	+ {
	1699	+ result = Traits::low(result, lead);
	1700	+ data += 1;
	1701	+ size -= 1;
	1702	+ }
	1703	+ // U+E000..U+FFFF
	1704	+ else if (static_cast<unsigned int>(lead - 0xE000) < 0x2000)
	1705	+ {
	1706	+ result = Traits::low(result, lead);
	1707	+ data += 1;
	1708	+ size -= 1;
	1709	+ }
	1710	+ // surrogate pair lead
	1711	+ else if (static_cast<unsigned int>(lead - 0xD800) < 0x400 && size >= 2)
	1712	+ {
	1713	+ uint16_t next = opt_swap::value ? endian_swap(data[1]) : data[1];
	1714	+
	1715	+ if (static_cast<unsigned int>(next - 0xDC00) < 0x400)
	1716	+ {
	1717	+ result = Traits::high(result, 0x10000 + ((lead & 0x3ff) << 10) + (next & 0x3ff));
	1718	+ data += 2;
	1719	+ size -= 2;
	1720	+ }
	1721	+ else
	1722	+ {
	1723	+ data += 1;
	1724	+ size -= 1;
	1725	+ }
	1726	+ }
	1727	+ else
	1728	+ {
	1729	+ data += 1;
	1730	+ size -= 1;
	1731	+ }
	1732	+ }
	1733	+
	1734	+ return result;
	1735	+ }
	1736	+ };
	1737	+
	1738	+ template <typename opt_swap> struct utf32_decoder
	1739	+ {
	1740	+ typedef uint32_t type;
	1741	+
	1742	+ template <typename Traits> static inline typename Traits::value_type process(const uint32_t* data, size_t size, typename Traits::value_type result, Traits)
	1743	+ {
	1744	+ while (size)
	1745	+ {
	1746	+ uint32_t lead = opt_swap::value ? endian_swap(data) : data;
	1747	+
	1748	+ // U+0000..U+FFFF
	1749	+ if (lead < 0x10000)
	1750	+ {
	1751	+ result = Traits::low(result, lead);
	1752	+ data += 1;
	1753	+ size -= 1;
	1754	+ }
	1755	+ // U+10000..U+10FFFF
	1756	+ else
	1757	+ {
	1758	+ result = Traits::high(result, lead);
	1759	+ data += 1;
	1760	+ size -= 1;
	1761	+ }
	1762	+ }
	1763	+
	1764	+ return result;
	1765	+ }
	1766	+ };
	1767	+
	1768	+ struct latin1_decoder
	1769	+ {
	1770	+ typedef uint8_t type;
	1771	+
	1772	+ template <typename Traits> static inline typename Traits::value_type process(const uint8_t* data, size_t size, typename Traits::value_type result, Traits)
	1773	+ {
	1774	+ while (size)
	1775	+ {
	1776	+ result = Traits::low(result, *data);
	1777	+ data += 1;
	1778	+ size -= 1;
	1779	+ }
	1780	+
	1781	+ return result;
	1782	+ }
	1783	+ };
	1784	+
	1785	+ template <size_t size> struct wchar_selector;
	1786	+
	1787	+ template <> struct wchar_selector<2>
	1788	+ {
	1789	+ typedef uint16_t type;
	1790	+ typedef utf16_counter counter;
	1791	+ typedef utf16_writer writer;
	1792	+ typedef utf16_decoder<opt_false> decoder;
	1793	+ };
	1794	+
	1795	+ template <> struct wchar_selector<4>
	1796	+ {
	1797	+ typedef uint32_t type;
	1798	+ typedef utf32_counter counter;
	1799	+ typedef utf32_writer writer;
	1800	+ typedef utf32_decoder<opt_false> decoder;
	1801	+ };
	1802	+
	1803	+ typedef wchar_selector<sizeof(wchar_t)>::counter wchar_counter;
	1804	+ typedef wchar_selector<sizeof(wchar_t)>::writer wchar_writer;
	1805	+
	1806	+ struct wchar_decoder
	1807	+ {
	1808	+ typedef wchar_t type;
	1809	+
	1810	+ template <typename Traits> static inline typename Traits::value_type process(const wchar_t* data, size_t size, typename Traits::value_type result, Traits traits)
	1811	+ {
	1812	+ typedef wchar_selector<sizeof(wchar_t)>::decoder decoder;
	1813	+
	1814	+ return decoder::process(reinterpret_cast<const typename decoder::type*>(data), size, result, traits);
	1815	+ }
	1816	+ };
	1817	+
	1818	+#ifdef PUGIXML_WCHAR_MODE
	1819	+ PUGI__FN void convert_wchar_endian_swap(wchar_t* result, const wchar_t* data, size_t length)
	1820	+ {
	1821	+ for (size_t i = 0; i < length; ++i)
	1822	+ result[i] = static_cast<wchar_t>(endian_swap(static_cast<wchar_selector<sizeof(wchar_t)>::type>(data[i])));
	1823	+ }
	1824	+#endif
	1825	+PUGI__NS_END
	1826	+
	1827	+PUGI__NS_BEGIN
	1828	+ enum chartype_t
	1829	+ {
	1830	+ ct_parse_pcdata = 1, // \0, &, \r, <
	1831	+ ct_parse_attr = 2, // \0, &, \r, ', "
	1832	+ ct_parse_attr_ws = 4, // \0, &, \r, ', ", \n, tab
	1833	+ ct_space = 8, // \r, \n, space, tab
	1834	+ ct_parse_cdata = 16, // \0, ], >, \r
	1835	+ ct_parse_comment = 32, // \0, -, >, \r
	1836	+ ct_symbol = 64, // Any symbol > 127, a-z, A-Z, 0-9, _, :, -, .
	1837	+ ct_start_symbol = 128 // Any symbol > 127, a-z, A-Z, _, :
	1838	+ };
	1839	+
	1840	+ static const unsigned char chartype_table[256] =
	1841	+ {
	1842	+ 55, 0, 0, 0, 0, 0, 0, 0, 0, 12, 12, 0, 0, 63, 0, 0, // 0-15
	1843	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16-31
	1844	+ 8, 0, 6, 0, 0, 0, 7, 6, 0, 0, 0, 0, 0, 96, 64, 0, // 32-47
	1845	+ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 192, 0, 1, 0, 48, 0, // 48-63
	1846	+ 0, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, // 64-79
	1847	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 0, 0, 16, 0, 192, // 80-95
	1848	+ 0, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, // 96-111
	1849	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 0, 0, 0, 0, 0, // 112-127
	1850	+
	1851	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, // 128+
	1852	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
	1853	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
	1854	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
	1855	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
	1856	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
	1857	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
	1858	+ 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192
	1859	+ };
	1860	+
	1861	+ enum chartypex_t
	1862	+ {
	1863	+ ctx_special_pcdata = 1, // Any symbol >= 0 and < 32 (except \t, \r, \n), &, <, >
	1864	+ ctx_special_attr = 2, // Any symbol >= 0 and < 32, &, <, ", '
	1865	+ ctx_start_symbol = 4, // Any symbol > 127, a-z, A-Z, _
	1866	+ ctx_digit = 8, // 0-9
	1867	+ ctx_symbol = 16 // Any symbol > 127, a-z, A-Z, 0-9, _, -, .
	1868	+ };
	1869	+
	1870	+ static const unsigned char chartypex_table[256] =
	1871	+ {
	1872	+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 3, 3, 2, 3, 3, // 0-15
	1873	+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 16-31
	1874	+ 0, 0, 2, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 16, 16, 0, // 32-47
	1875	+ 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 3, 0, 1, 0, // 48-63
	1876	+
	1877	+ 0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, // 64-79
	1878	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 20, // 80-95
	1879	+ 0, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, // 96-111
	1880	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 0, // 112-127
	1881	+
	1882	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, // 128+
	1883	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
	1884	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
	1885	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
	1886	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
	1887	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
	1888	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
	1889	+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20
	1890	+ };
	1891	+
	1892	+#ifdef PUGIXML_WCHAR_MODE
	1893	+ #define PUGI__IS_CHARTYPE_IMPL(c, ct, table) ((static_cast<unsigned int>(c) < 128 ? table[static_cast<unsigned int>(c)] : table[128]) & (ct))
	1894	+#else
	1895	+ #define PUGI__IS_CHARTYPE_IMPL(c, ct, table) (table[static_cast<unsigned char>(c)] & (ct))
	1896	+#endif
	1897	+
	1898	+ #define PUGI__IS_CHARTYPE(c, ct) PUGI__IS_CHARTYPE_IMPL(c, ct, chartype_table)
	1899	+ #define PUGI__IS_CHARTYPEX(c, ct) PUGI__IS_CHARTYPE_IMPL(c, ct, chartypex_table)
	1900	+
	1901	+ PUGI__FN bool is_little_endian()
	1902	+ {
	1903	+ unsigned int ui = 1;
	1904	+
	1905	+ return reinterpret_cast<unsigned char>(&ui) == 1;
	1906	+ }
	1907	+
	1908	+ PUGI__FN xml_encoding get_wchar_encoding()
	1909	+ {
	1910	+ PUGI__STATIC_ASSERT(sizeof(wchar_t) == 2 \|\| sizeof(wchar_t) == 4);
	1911	+
	1912	+ if (sizeof(wchar_t) == 2)
	1913	+ return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
	1914	+ else
	1915	+ return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
	1916	+ }
	1917	+
	1918	+ PUGI__FN bool parse_declaration_encoding(const uint8_t* data, size_t size, const uint8_t*& out_encoding, size_t& out_length)
	1919	+ {
	1920	+ #define PUGI__SCANCHAR(ch) { if (offset >= size \|\| data[offset] != ch) return false; offset++; }
	1921	+ #define PUGI__SCANCHARTYPE(ct) { while (offset < size && PUGI__IS_CHARTYPE(data[offset], ct)) offset++; }
	1922	+
	1923	+ // check if we have a non-empty XML declaration
	1924	+ if (size < 6 \|\| !((data[0] == '<') & (data[1] == '?') & (data[2] == 'x') & (data[3] == 'm') & (data[4] == 'l') && PUGI__IS_CHARTYPE(data[5], ct_space)))
	1925	+ return false;
	1926	+
	1927	+ // scan XML declaration until the encoding field
	1928	+ for (size_t i = 6; i + 1 < size; ++i)
	1929	+ {
	1930	+ // declaration can not contain ? in quoted values
	1931	+ if (data[i] == '?')
	1932	+ return false;
	1933	+
	1934	+ if (data[i] == 'e' && data[i + 1] == 'n')
	1935	+ {
	1936	+ size_t offset = i;
	1937	+
	1938	+ // encoding follows the version field which can't contain 'en' so this has to be the encoding if XML is well formed
	1939	+ PUGI__SCANCHAR('e'); PUGI__SCANCHAR('n'); PUGI__SCANCHAR('c'); PUGI__SCANCHAR('o');
	1940	+ PUGI__SCANCHAR('d'); PUGI__SCANCHAR('i'); PUGI__SCANCHAR('n'); PUGI__SCANCHAR('g');
	1941	+
	1942	+ // S? = S?
	1943	+ PUGI__SCANCHARTYPE(ct_space);
	1944	+ PUGI__SCANCHAR('=');
	1945	+ PUGI__SCANCHARTYPE(ct_space);
	1946	+
	1947	+ // the only two valid delimiters are ' and "
	1948	+ uint8_t delimiter = (offset < size && data[offset] == '"') ? '"' : '\'';
	1949	+
	1950	+ PUGI__SCANCHAR(delimiter);
	1951	+
	1952	+ size_t start = offset;
	1953	+
	1954	+ out_encoding = data + offset;
	1955	+
	1956	+ PUGI__SCANCHARTYPE(ct_symbol);
	1957	+
	1958	+ out_length = offset - start;
	1959	+
	1960	+ PUGI__SCANCHAR(delimiter);
	1961	+
	1962	+ return true;
	1963	+ }
	1964	+ }
	1965	+
	1966	+ return false;
	1967	+
	1968	+ #undef PUGI__SCANCHAR
	1969	+ #undef PUGI__SCANCHARTYPE
	1970	+ }
	1971	+
	1972	+ PUGI__FN xml_encoding guess_buffer_encoding(const uint8_t* data, size_t size)
	1973	+ {
	1974	+ // skip encoding autodetection if input buffer is too small
	1975	+ if (size < 4) return encoding_utf8;
	1976	+
	1977	+ uint8_t d0 = data[0], d1 = data[1], d2 = data[2], d3 = data[3];
	1978	+
	1979	+ // look for BOM in first few bytes
	1980	+ if (d0 == 0 && d1 == 0 && d2 == 0xfe && d3 == 0xff) return encoding_utf32_be;
	1981	+ if (d0 == 0xff && d1 == 0xfe && d2 == 0 && d3 == 0) return encoding_utf32_le;
	1982	+ if (d0 == 0xfe && d1 == 0xff) return encoding_utf16_be;
	1983	+ if (d0 == 0xff && d1 == 0xfe) return encoding_utf16_le;
	1984	+ if (d0 == 0xef && d1 == 0xbb && d2 == 0xbf) return encoding_utf8;
	1985	+
	1986	+ // look for <, <? or <?xm in various encodings
	1987	+ if (d0 == 0 && d1 == 0 && d2 == 0 && d3 == 0x3c) return encoding_utf32_be;
	1988	+ if (d0 == 0x3c && d1 == 0 && d2 == 0 && d3 == 0) return encoding_utf32_le;
	1989	+ if (d0 == 0 && d1 == 0x3c && d2 == 0 && d3 == 0x3f) return encoding_utf16_be;
	1990	+ if (d0 == 0x3c && d1 == 0 && d2 == 0x3f && d3 == 0) return encoding_utf16_le;
	1991	+
	1992	+ // look for utf16 < followed by node name (this may fail, but is better than utf8 since it's zero terminated so early)
	1993	+ if (d0 == 0 && d1 == 0x3c) return encoding_utf16_be;
	1994	+ if (d0 == 0x3c && d1 == 0) return encoding_utf16_le;
	1995	+
	1996	+ // no known BOM detected; parse declaration
	1997	+ const uint8_t* enc = 0;
	1998	+ size_t enc_length = 0;
	1999	+
	2000	+ if (d0 == 0x3c && d1 == 0x3f && d2 == 0x78 && d3 == 0x6d && parse_declaration_encoding(data, size, enc, enc_length))
	2001	+ {
	2002	+ // iso-8859-1 (case-insensitive)
	2003	+ if (enc_length == 10
	2004	+ && (enc[0] \| ' ') == 'i' && (enc[1] \| ' ') == 's' && (enc[2] \| ' ') == 'o'
	2005	+ && enc[3] == '-' && enc[4] == '8' && enc[5] == '8' && enc[6] == '5' && enc[7] == '9'
	2006	+ && enc[8] == '-' && enc[9] == '1')
	2007	+ return encoding_latin1;
	2008	+
	2009	+ // latin1 (case-insensitive)
	2010	+ if (enc_length == 6
	2011	+ && (enc[0] \| ' ') == 'l' && (enc[1] \| ' ') == 'a' && (enc[2] \| ' ') == 't'
	2012	+ && (enc[3] \| ' ') == 'i' && (enc[4] \| ' ') == 'n'
	2013	+ && enc[5] == '1')
	2014	+ return encoding_latin1;
	2015	+ }
	2016	+
	2017	+ return encoding_utf8;
	2018	+ }
	2019	+
	2020	+ PUGI__FN xml_encoding get_buffer_encoding(xml_encoding encoding, const void* contents, size_t size)
	2021	+ {
	2022	+ // replace wchar encoding with utf implementation
	2023	+ if (encoding == encoding_wchar) return get_wchar_encoding();
	2024	+
	2025	+ // replace utf16 encoding with utf16 with specific endianness
	2026	+ if (encoding == encoding_utf16) return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
	2027	+
	2028	+ // replace utf32 encoding with utf32 with specific endianness
	2029	+ if (encoding == encoding_utf32) return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
	2030	+
	2031	+ // only do autodetection if no explicit encoding is requested
	2032	+ if (encoding != encoding_auto) return encoding;
	2033	+
	2034	+ // try to guess encoding (based on XML specification, Appendix F.1)
	2035	+ const uint8_t* data = static_cast<const uint8_t*>(contents);
	2036	+
	2037	+ return guess_buffer_encoding(data, size);
	2038	+ }
	2039	+
	2040	+ PUGI__FN bool get_mutable_buffer(char_t& out_buffer, size_t& out_length, const void contents, size_t size, bool is_mutable)
	2041	+ {
	2042	+ size_t length = size / sizeof(char_t);
	2043	+
	2044	+ if (is_mutable)
	2045	+ {
	2046	+ out_buffer = static_cast<char_t>(const_cast<void>(contents));
	2047	+ out_length = length;
	2048	+ }
	2049	+ else
	2050	+ {
	2051	+ char_t* buffer = static_cast<char_t>(xml_memory::allocate((length + 1) sizeof(char_t)));
	2052	+ if (!buffer) return false;
	2053	+
	2054	+ if (contents)
	2055	+ memcpy(buffer, contents, length * sizeof(char_t));
	2056	+ else
	2057	+ assert(length == 0);
	2058	+
	2059	+ buffer[length] = 0;
	2060	+
	2061	+ out_buffer = buffer;
	2062	+ out_length = length + 1;
	2063	+ }
	2064	+
	2065	+ return true;
	2066	+ }
	2067	+
	2068	+#ifdef PUGIXML_WCHAR_MODE
	2069	+ PUGI__FN bool need_endian_swap_utf(xml_encoding le, xml_encoding re)
	2070	+ {
	2071	+ return (le == encoding_utf16_be && re == encoding_utf16_le) \|\| (le == encoding_utf16_le && re == encoding_utf16_be) \|\|
	2072	+ (le == encoding_utf32_be && re == encoding_utf32_le) \|\| (le == encoding_utf32_le && re == encoding_utf32_be);
	2073	+ }
	2074	+
	2075	+ PUGI__FN bool convert_buffer_endian_swap(char_t& out_buffer, size_t& out_length, const void contents, size_t size, bool is_mutable)
	2076	+ {
	2077	+ const char_t* data = static_cast<const char_t*>(contents);
	2078	+ size_t length = size / sizeof(char_t);
	2079	+
	2080	+ if (is_mutable)
	2081	+ {
	2082	+ char_t* buffer = const_cast<char_t*>(data);
	2083	+
	2084	+ convert_wchar_endian_swap(buffer, data, length);
	2085	+
	2086	+ out_buffer = buffer;
	2087	+ out_length = length;
	2088	+ }
	2089	+ else
	2090	+ {
	2091	+ char_t* buffer = static_cast<char_t>(xml_memory::allocate((length + 1) sizeof(char_t)));
	2092	+ if (!buffer) return false;
	2093	+
	2094	+ convert_wchar_endian_swap(buffer, data, length);
	2095	+ buffer[length] = 0;
	2096	+
	2097	+ out_buffer = buffer;
	2098	+ out_length = length + 1;
	2099	+ }
	2100	+
	2101	+ return true;
	2102	+ }
	2103	+
	2104	+ template <typename D> PUGI__FN bool convert_buffer_generic(char_t& out_buffer, size_t& out_length, const void contents, size_t size, D)
	2105	+ {
	2106	+ const typename D::type* data = static_cast<const typename D::type*>(contents);
	2107	+ size_t data_length = size / sizeof(typename D::type);
	2108	+
	2109	+ // first pass: get length in wchar_t units
	2110	+ size_t length = D::process(data, data_length, 0, wchar_counter());
	2111	+
	2112	+ // allocate buffer of suitable length
	2113	+ char_t* buffer = static_cast<char_t>(xml_memory::allocate((length + 1) sizeof(char_t)));
	2114	+ if (!buffer) return false;
	2115	+
	2116	+ // second pass: convert utf16 input to wchar_t
	2117	+ wchar_writer::value_type obegin = reinterpret_cast<wchar_writer::value_type>(buffer);
	2118	+ wchar_writer::value_type oend = D::process(data, data_length, obegin, wchar_writer());
	2119	+
	2120	+ assert(oend == obegin + length);
	2121	+ *oend = 0;
	2122	+
	2123	+ out_buffer = buffer;
	2124	+ out_length = length + 1;
	2125	+
	2126	+ return true;
	2127	+ }
	2128	+
	2129	+ PUGI__FN bool convert_buffer(char_t& out_buffer, size_t& out_length, xml_encoding encoding, const void contents, size_t size, bool is_mutable)
	2130	+ {
	2131	+ // get native encoding
	2132	+ xml_encoding wchar_encoding = get_wchar_encoding();
	2133	+
	2134	+ // fast path: no conversion required
	2135	+ if (encoding == wchar_encoding)
	2136	+ return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
	2137	+
	2138	+ // only endian-swapping is required
	2139	+ if (need_endian_swap_utf(encoding, wchar_encoding))
	2140	+ return convert_buffer_endian_swap(out_buffer, out_length, contents, size, is_mutable);
	2141	+
	2142	+ // source encoding is utf8
	2143	+ if (encoding == encoding_utf8)
	2144	+ return convert_buffer_generic(out_buffer, out_length, contents, size, utf8_decoder());
	2145	+
	2146	+ // source encoding is utf16
	2147	+ if (encoding == encoding_utf16_be \|\| encoding == encoding_utf16_le)
	2148	+ {
	2149	+ xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
	2150	+
	2151	+ return (native_encoding == encoding) ?
	2152	+ convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_false>()) :
	2153	+ convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_true>());
	2154	+ }
	2155	+
	2156	+ // source encoding is utf32
	2157	+ if (encoding == encoding_utf32_be \|\| encoding == encoding_utf32_le)
	2158	+ {
	2159	+ xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
	2160	+
	2161	+ return (native_encoding == encoding) ?
	2162	+ convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_false>()) :
	2163	+ convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_true>());
	2164	+ }
	2165	+
	2166	+ // source encoding is latin1
	2167	+ if (encoding == encoding_latin1)
	2168	+ return convert_buffer_generic(out_buffer, out_length, contents, size, latin1_decoder());
	2169	+
	2170	+ assert(false && "Invalid encoding"); // unreachable
	2171	+ return false;
	2172	+ }
	2173	+#else
	2174	+ template <typename D> PUGI__FN bool convert_buffer_generic(char_t& out_buffer, size_t& out_length, const void contents, size_t size, D)
	2175	+ {
	2176	+ const typename D::type* data = static_cast<const typename D::type*>(contents);
	2177	+ size_t data_length = size / sizeof(typename D::type);
	2178	+
	2179	+ // first pass: get length in utf8 units
	2180	+ size_t length = D::process(data, data_length, 0, utf8_counter());
	2181	+
	2182	+ // allocate buffer of suitable length
	2183	+ char_t* buffer = static_cast<char_t>(xml_memory::allocate((length + 1) sizeof(char_t)));
	2184	+ if (!buffer) return false;
	2185	+
	2186	+ // second pass: convert utf16 input to utf8
	2187	+ uint8_t* obegin = reinterpret_cast<uint8_t*>(buffer);
	2188	+ uint8_t* oend = D::process(data, data_length, obegin, utf8_writer());
	2189	+
	2190	+ assert(oend == obegin + length);
	2191	+ *oend = 0;
	2192	+
	2193	+ out_buffer = buffer;
	2194	+ out_length = length + 1;
	2195	+
	2196	+ return true;
	2197	+ }
	2198	+
	2199	+ PUGI__FN size_t get_latin1_7bit_prefix_length(const uint8_t* data, size_t size)
	2200	+ {
	2201	+ for (size_t i = 0; i < size; ++i)
	2202	+ if (data[i] > 127)
	2203	+ return i;
	2204	+
	2205	+ return size;
	2206	+ }
	2207	+
	2208	+ PUGI__FN bool convert_buffer_latin1(char_t& out_buffer, size_t& out_length, const void contents, size_t size, bool is_mutable)
	2209	+ {
	2210	+ const uint8_t* data = static_cast<const uint8_t*>(contents);
	2211	+ size_t data_length = size;
	2212	+
	2213	+ // get size of prefix that does not need utf8 conversion
	2214	+ size_t prefix_length = get_latin1_7bit_prefix_length(data, data_length);
	2215	+ assert(prefix_length <= data_length);
	2216	+
	2217	+ const uint8_t* postfix = data + prefix_length;
	2218	+ size_t postfix_length = data_length - prefix_length;
	2219	+
	2220	+ // if no conversion is needed, just return the original buffer
	2221	+ if (postfix_length == 0) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
	2222	+
	2223	+ // first pass: get length in utf8 units
	2224	+ size_t length = prefix_length + latin1_decoder::process(postfix, postfix_length, 0, utf8_counter());
	2225	+
	2226	+ // allocate buffer of suitable length
	2227	+ char_t* buffer = static_cast<char_t>(xml_memory::allocate((length + 1) sizeof(char_t)));
	2228	+ if (!buffer) return false;
	2229	+
	2230	+ // second pass: convert latin1 input to utf8
	2231	+ memcpy(buffer, data, prefix_length);
	2232	+
	2233	+ uint8_t* obegin = reinterpret_cast<uint8_t*>(buffer);
	2234	+ uint8_t* oend = latin1_decoder::process(postfix, postfix_length, obegin + prefix_length, utf8_writer());
	2235	+
	2236	+ assert(oend == obegin + length);
	2237	+ *oend = 0;
	2238	+
	2239	+ out_buffer = buffer;
	2240	+ out_length = length + 1;
	2241	+
	2242	+ return true;
	2243	+ }
	2244	+
	2245	+ PUGI__FN bool convert_buffer(char_t& out_buffer, size_t& out_length, xml_encoding encoding, const void contents, size_t size, bool is_mutable)
	2246	+ {
	2247	+ // fast path: no conversion required
	2248	+ if (encoding == encoding_utf8)
	2249	+ return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
	2250	+
	2251	+ // source encoding is utf16
	2252	+ if (encoding == encoding_utf16_be \|\| encoding == encoding_utf16_le)
	2253	+ {
	2254	+ xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
	2255	+
	2256	+ return (native_encoding == encoding) ?
	2257	+ convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_false>()) :
	2258	+ convert_buffer_generic(out_buffer, out_length, contents, size, utf16_decoder<opt_true>());
	2259	+ }
	2260	+
	2261	+ // source encoding is utf32
	2262	+ if (encoding == encoding_utf32_be \|\| encoding == encoding_utf32_le)
	2263	+ {
	2264	+ xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
	2265	+
	2266	+ return (native_encoding == encoding) ?
	2267	+ convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_false>()) :
	2268	+ convert_buffer_generic(out_buffer, out_length, contents, size, utf32_decoder<opt_true>());
	2269	+ }
	2270	+
	2271	+ // source encoding is latin1
	2272	+ if (encoding == encoding_latin1)
	2273	+ return convert_buffer_latin1(out_buffer, out_length, contents, size, is_mutable);
	2274	+
	2275	+ assert(false && "Invalid encoding"); // unreachable
	2276	+ return false;
	2277	+ }
	2278	+#endif
	2279	+
	2280	+ PUGI__FN size_t as_utf8_begin(const wchar_t* str, size_t length)
	2281	+ {
	2282	+ // get length in utf8 characters
	2283	+ return wchar_decoder::process(str, length, 0, utf8_counter());
	2284	+ }
	2285	+
	2286	+ PUGI__FN void as_utf8_end(char* buffer, size_t size, const wchar_t* str, size_t length)
	2287	+ {
	2288	+ // convert to utf8
	2289	+ uint8_t* begin = reinterpret_cast<uint8_t*>(buffer);
	2290	+ uint8_t* end = wchar_decoder::process(str, length, begin, utf8_writer());
	2291	+
	2292	+ assert(begin + size == end);
	2293	+ (void)!end;
	2294	+ (void)!size;
	2295	+ }
	2296	+
	2297	+#ifndef PUGIXML_NO_STL
	2298	+ PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length)
	2299	+ {
	2300	+ // first pass: get length in utf8 characters
	2301	+ size_t size = as_utf8_begin(str, length);
	2302	+
	2303	+ // allocate resulting string
	2304	+ std::string result;
	2305	+ result.resize(size);
	2306	+
	2307	+ // second pass: convert to utf8
	2308	+ if (size > 0) as_utf8_end(&result[0], size, str, length);
	2309	+
	2310	+ return result;
	2311	+ }
	2312	+
	2313	+ PUGI__FN std::basic_string<wchar_t> as_wide_impl(const char* str, size_t size)
	2314	+ {
	2315	+ const uint8_t* data = reinterpret_cast<const uint8_t*>(str);
	2316	+
	2317	+ // first pass: get length in wchar_t units
	2318	+ size_t length = utf8_decoder::process(data, size, 0, wchar_counter());
	2319	+
	2320	+ // allocate resulting string
	2321	+ std::basic_string<wchar_t> result;
	2322	+ result.resize(length);
	2323	+
	2324	+ // second pass: convert to wchar_t
	2325	+ if (length > 0)
	2326	+ {
	2327	+ wchar_writer::value_type begin = reinterpret_cast<wchar_writer::value_type>(&result[0]);
	2328	+ wchar_writer::value_type end = utf8_decoder::process(data, size, begin, wchar_writer());
	2329	+
	2330	+ assert(begin + length == end);
	2331	+ (void)!end;
	2332	+ }
	2333	+
	2334	+ return result;
	2335	+ }
	2336	+#endif
	2337	+
	2338	+ template <typename Header>
	2339	+ inline bool strcpy_insitu_allow(size_t length, const Header& header, uintptr_t header_mask, char_t* target)
	2340	+ {
	2341	+ // never reuse shared memory
	2342	+ if (header & xml_memory_page_contents_shared_mask) return false;
	2343	+
	2344	+ size_t target_length = strlength(target);
	2345	+
	2346	+ // always reuse document buffer memory if possible
	2347	+ if ((header & header_mask) == 0) return target_length >= length;
	2348	+
	2349	+ // reuse heap memory if waste is not too great
	2350	+ const size_t reuse_threshold = 32;
	2351	+
	2352	+ return target_length >= length && (target_length < reuse_threshold \|\| target_length - length < target_length / 2);
	2353	+ }
	2354	+
	2355	+ template <typename String, typename Header>
	2356	+ PUGI__FN bool strcpy_insitu(String& dest, Header& header, uintptr_t header_mask, const char_t* source, size_t source_length)
	2357	+ {
	2358	+ if (source_length == 0)
	2359	+ {
	2360	+ // empty string and null pointer are equivalent, so just deallocate old memory
	2361	+ xml_allocator* alloc = PUGI__GETPAGE_IMPL(header)->allocator;
	2362	+
	2363	+ if (header & header_mask) alloc->deallocate_string(dest);
	2364	+
	2365	+ // mark the string as not allocated
	2366	+ dest = 0;
	2367	+ header &= ~header_mask;
	2368	+
	2369	+ return true;
	2370	+ }
	2371	+ else if (dest && strcpy_insitu_allow(source_length, header, header_mask, dest))
	2372	+ {
	2373	+ // we can reuse old buffer, so just copy the new data (including zero terminator)
	2374	+ memcpy(dest, source, source_length * sizeof(char_t));
	2375	+ dest[source_length] = 0;
	2376	+
	2377	+ return true;
	2378	+ }
	2379	+ else
	2380	+ {
	2381	+ xml_allocator* alloc = PUGI__GETPAGE_IMPL(header)->allocator;
	2382	+
	2383	+ if (!alloc->reserve()) return false;
	2384	+
	2385	+ // allocate new buffer
	2386	+ char_t* buf = alloc->allocate_string(source_length + 1);
	2387	+ if (!buf) return false;
	2388	+
	2389	+ // copy the string (including zero terminator)
	2390	+ memcpy(buf, source, source_length * sizeof(char_t));
	2391	+ buf[source_length] = 0;
	2392	+
	2393	+ // deallocate old buffer (after the above to protect against overlapping memory and/or allocation failures)
	2394	+ if (header & header_mask) alloc->deallocate_string(dest);
	2395	+
	2396	+ // the string is now allocated, so set the flag
	2397	+ dest = buf;
	2398	+ header \|= header_mask;
	2399	+
	2400	+ return true;
	2401	+ }
	2402	+ }
	2403	+
	2404	+ struct gap
	2405	+ {
	2406	+ char_t* end;
	2407	+ size_t size;
	2408	+
	2409	+ gap(): end(0), size(0)
	2410	+ {
	2411	+ }
	2412	+
	2413	+ // Push new gap, move s count bytes further (skipping the gap).
	2414	+ // Collapse previous gap.
	2415	+ void push(char_t*& s, size_t count)
	2416	+ {
	2417	+ if (end) // there was a gap already; collapse it
	2418	+ {
	2419	+ // Move [old_gap_end, new_gap_start) to [old_gap_start, ...)
	2420	+ assert(s >= end);
	2421	+ memmove(end - size, end, reinterpret_cast<char>(s) - reinterpret_cast<char>(end));
	2422	+ }
	2423	+
	2424	+ s += count; // end of current gap
	2425	+
	2426	+ // "merge" two gaps
	2427	+ end = s;
	2428	+ size += count;
	2429	+ }
	2430	+
	2431	+ // Collapse all gaps, return past-the-end pointer
	2432	+ char_t* flush(char_t* s)
	2433	+ {
	2434	+ if (end)
	2435	+ {
	2436	+ // Move [old_gap_end, current_pos) to [old_gap_start, ...)
	2437	+ assert(s >= end);
	2438	+ memmove(end - size, end, reinterpret_cast<char>(s) - reinterpret_cast<char>(end));
	2439	+
	2440	+ return s - size;
	2441	+ }
	2442	+ else return s;
	2443	+ }
	2444	+ };
	2445	+
	2446	+ PUGI__FN char_t* strconv_escape(char_t* s, gap& g)
	2447	+ {
	2448	+ char_t* stre = s + 1;
	2449	+
	2450	+ switch (*stre)
	2451	+ {
	2452	+ case '#': // &#...
	2453	+ {
	2454	+ unsigned int ucsc = 0;
	2455	+
	2456	+ if (stre[1] == 'x') // &#x... (hex code)
	2457	+ {
	2458	+ stre += 2;
	2459	+
	2460	+ char_t ch = *stre;
	2461	+
	2462	+ if (ch == ';') return stre;
	2463	+
	2464	+ for (;;)
	2465	+ {
	2466	+ if (static_cast<unsigned int>(ch - '0') <= 9)
	2467	+ ucsc = 16 * ucsc + (ch - '0');
	2468	+ else if (static_cast<unsigned int>((ch \| ' ') - 'a') <= 5)
	2469	+ ucsc = 16 * ucsc + ((ch \| ' ') - 'a' + 10);
	2470	+ else if (ch == ';')
	2471	+ break;
	2472	+ else // cancel
	2473	+ return stre;
	2474	+
	2475	+ ch = *++stre;
	2476	+ }
	2477	+
	2478	+ ++stre;
	2479	+ }
	2480	+ else // &#... (dec code)
	2481	+ {
	2482	+ char_t ch = *++stre;
	2483	+
	2484	+ if (ch == ';') return stre;
	2485	+
	2486	+ for (;;)
	2487	+ {
	2488	+ if (static_cast<unsigned int>(ch - '0') <= 9)
	2489	+ ucsc = 10 * ucsc + (ch - '0');
	2490	+ else if (ch == ';')
	2491	+ break;
	2492	+ else // cancel
	2493	+ return stre;
	2494	+
	2495	+ ch = *++stre;
	2496	+ }
	2497	+
	2498	+ ++stre;
	2499	+ }
	2500	+
	2501	+ #ifdef PUGIXML_WCHAR_MODE
	2502	+ s = reinterpret_cast<char_t*>(wchar_writer::any(reinterpret_cast<wchar_writer::value_type>(s), ucsc));
	2503	+ #else
	2504	+ s = reinterpret_cast<char_t>(utf8_writer::any(reinterpret_cast<uint8_t>(s), ucsc));
	2505	+ #endif
	2506	+
	2507	+ g.push(s, stre - s);
	2508	+ return stre;
	2509	+ }
	2510	+
	2511	+ case 'a': // &a
	2512	+ {
	2513	+ ++stre;
	2514	+
	2515	+ if (*stre == 'm') // &am
	2516	+ {
	2517	+ if (++stre == 'p' && ++stre == ';') // &
	2518	+ {
	2519	+ *s++ = '&';
	2520	+ ++stre;
	2521	+
	2522	+ g.push(s, stre - s);
	2523	+ return stre;
	2524	+ }
	2525	+ }
	2526	+ else if (*stre == 'p') // &ap
	2527	+ {
	2528	+ if (++stre == 'o' && ++stre == 's' && *++stre == ';') // '
	2529	+ {
	2530	+ *s++ = '\'';
	2531	+ ++stre;
	2532	+
	2533	+ g.push(s, stre - s);
	2534	+ return stre;
	2535	+ }
	2536	+ }
	2537	+ break;
	2538	+ }
	2539	+
	2540	+ case 'g': // &g
	2541	+ {
	2542	+ if (++stre == 't' && ++stre == ';') // >
	2543	+ {
	2544	+ *s++ = '>';
	2545	+ ++stre;
	2546	+
	2547	+ g.push(s, stre - s);
	2548	+ return stre;
	2549	+ }
	2550	+ break;
	2551	+ }
	2552	+
	2553	+ case 'l': // &l
	2554	+ {
	2555	+ if (++stre == 't' && ++stre == ';') // <
	2556	+ {
	2557	+ *s++ = '<';
	2558	+ ++stre;
	2559	+
	2560	+ g.push(s, stre - s);
	2561	+ return stre;
	2562	+ }
	2563	+ break;
	2564	+ }
	2565	+
	2566	+ case 'q': // &q
	2567	+ {
	2568	+ if (++stre == 'u' && ++stre == 'o' && ++stre == 't' && ++stre == ';') // "
	2569	+ {
	2570	+ *s++ = '"';
	2571	+ ++stre;
	2572	+
	2573	+ g.push(s, stre - s);
	2574	+ return stre;
	2575	+ }
	2576	+ break;
	2577	+ }
	2578	+
	2579	+ default:
	2580	+ break;
	2581	+ }
	2582	+
	2583	+ return stre;
	2584	+ }
	2585	+
	2586	+ // Parser utilities
	2587	+ #define PUGI__ENDSWITH(c, e) ((c) == (e) \|\| ((c) == 0 && endch == (e)))
	2588	+ #define PUGI__SKIPWS() { while (PUGI__IS_CHARTYPE(*s, ct_space)) ++s; }
	2589	+ #define PUGI__OPTSET(OPT) ( optmsk & (OPT) )
	2590	+ #define PUGI__PUSHNODE(TYPE) { cursor = append_new_node(cursor, *alloc, TYPE); if (!cursor) PUGI__THROW_ERROR(status_out_of_memory, s); }
	2591	+ #define PUGI__POPNODE() { cursor = cursor->parent; }
	2592	+ #define PUGI__SCANFOR(X) { while (*s != 0 && !(X)) ++s; }
	2593	+ #define PUGI__SCANWHILE(X) { while (X) ++s; }
	2594	+ #define PUGI__SCANWHILE_UNROLL(X) { for (;;) { char_t ss = s[0]; if (PUGI__UNLIKELY(!(X))) { break; } ss = s[1]; if (PUGI__UNLIKELY(!(X))) { s += 1; break; } ss = s[2]; if (PUGI__UNLIKELY(!(X))) { s += 2; break; } ss = s[3]; if (PUGI__UNLIKELY(!(X))) { s += 3; break; } s += 4; } }
	2595	+ #define PUGI__ENDSEG() { ch = s; s = 0; ++s; }
	2596	+ #define PUGI__THROW_ERROR(err, m) return error_offset = m, error_status = err, static_cast<char_t*>(0)
	2597	+ #define PUGI__CHECK_ERROR(err, m) { if (*s == 0) PUGI__THROW_ERROR(err, m); }
	2598	+
	2599	+ PUGI__FN char_t* strconv_comment(char_t* s, char_t endch)
	2600	+ {
	2601	+ gap g;
	2602	+
	2603	+ while (true)
	2604	+ {
	2605	+ PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_comment));
	2606	+
	2607	+ if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
	2608	+ {
	2609	+ *s++ = '\n'; // replace first one with 0x0a
	2610	+
	2611	+ if (*s == '\n') g.push(s, 1);
	2612	+ }
	2613	+ else if (s[0] == '-' && s[1] == '-' && PUGI__ENDSWITH(s[2], '>')) // comment ends here
	2614	+ {
	2615	+ *g.flush(s) = 0;
	2616	+
	2617	+ return s + (s[2] == '>' ? 3 : 2);
	2618	+ }
	2619	+ else if (*s == 0)
	2620	+ {
	2621	+ return 0;
	2622	+ }
	2623	+ else ++s;
	2624	+ }
	2625	+ }
	2626	+
	2627	+ PUGI__FN char_t* strconv_cdata(char_t* s, char_t endch)
	2628	+ {
	2629	+ gap g;
	2630	+
	2631	+ while (true)
	2632	+ {
	2633	+ PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_cdata));
	2634	+
	2635	+ if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
	2636	+ {
	2637	+ *s++ = '\n'; // replace first one with 0x0a
	2638	+
	2639	+ if (*s == '\n') g.push(s, 1);
	2640	+ }
	2641	+ else if (s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>')) // CDATA ends here
	2642	+ {
	2643	+ *g.flush(s) = 0;
	2644	+
	2645	+ return s + 1;
	2646	+ }
	2647	+ else if (*s == 0)
	2648	+ {
	2649	+ return 0;
	2650	+ }
	2651	+ else ++s;
	2652	+ }
	2653	+ }
	2654	+
	2655	+ typedef char_t* (strconv_pcdata_t)(char_t);
	2656	+
	2657	+ template <typename opt_trim, typename opt_eol, typename opt_escape> struct strconv_pcdata_impl
	2658	+ {
	2659	+ static char_t* parse(char_t* s)
	2660	+ {
	2661	+ gap g;
	2662	+
	2663	+ char_t* begin = s;
	2664	+
	2665	+ while (true)
	2666	+ {
	2667	+ PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_pcdata));
	2668	+
	2669	+ if (*s == '<') // PCDATA ends here
	2670	+ {
	2671	+ char_t* end = g.flush(s);
	2672	+
	2673	+ if (opt_trim::value)
	2674	+ while (end > begin && PUGI__IS_CHARTYPE(end[-1], ct_space))
	2675	+ --end;
	2676	+
	2677	+ *end = 0;
	2678	+
	2679	+ return s + 1;
	2680	+ }
	2681	+ else if (opt_eol::value && *s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
	2682	+ {
	2683	+ *s++ = '\n'; // replace first one with 0x0a
	2684	+
	2685	+ if (*s == '\n') g.push(s, 1);
	2686	+ }
	2687	+ else if (opt_escape::value && *s == '&')
	2688	+ {
	2689	+ s = strconv_escape(s, g);
	2690	+ }
	2691	+ else if (*s == 0)
	2692	+ {
	2693	+ char_t* end = g.flush(s);
	2694	+
	2695	+ if (opt_trim::value)
	2696	+ while (end > begin && PUGI__IS_CHARTYPE(end[-1], ct_space))
	2697	+ --end;
	2698	+
	2699	+ *end = 0;
	2700	+
	2701	+ return s;
	2702	+ }
	2703	+ else ++s;
	2704	+ }
	2705	+ }
	2706	+ };
	2707	+
	2708	+ PUGI__FN strconv_pcdata_t get_strconv_pcdata(unsigned int optmask)
	2709	+ {
	2710	+ PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_trim_pcdata == 0x0800);
	2711	+
	2712	+ switch (((optmask >> 4) & 3) \| ((optmask >> 9) & 4)) // get bitmask for flags (trim eol escapes); this simultaneously checks 3 options from assertion above
	2713	+ {
	2714	+ case 0: return strconv_pcdata_impl<opt_false, opt_false, opt_false>::parse;
	2715	+ case 1: return strconv_pcdata_impl<opt_false, opt_false, opt_true>::parse;
	2716	+ case 2: return strconv_pcdata_impl<opt_false, opt_true, opt_false>::parse;
	2717	+ case 3: return strconv_pcdata_impl<opt_false, opt_true, opt_true>::parse;
	2718	+ case 4: return strconv_pcdata_impl<opt_true, opt_false, opt_false>::parse;
	2719	+ case 5: return strconv_pcdata_impl<opt_true, opt_false, opt_true>::parse;
	2720	+ case 6: return strconv_pcdata_impl<opt_true, opt_true, opt_false>::parse;
	2721	+ case 7: return strconv_pcdata_impl<opt_true, opt_true, opt_true>::parse;
	2722	+ default: assert(false); return 0; // unreachable
	2723	+ }
	2724	+ }
	2725	+
	2726	+ typedef char_t* (strconv_attribute_t)(char_t, char_t);
	2727	+
	2728	+ template <typename opt_escape> struct strconv_attribute_impl
	2729	+ {
	2730	+ static char_t* parse_wnorm(char_t* s, char_t end_quote)
	2731	+ {
	2732	+ gap g;
	2733	+
	2734	+ // trim leading whitespaces
	2735	+ if (PUGI__IS_CHARTYPE(*s, ct_space))
	2736	+ {
	2737	+ char_t* str = s;
	2738	+
	2739	+ do ++str;
	2740	+ while (PUGI__IS_CHARTYPE(*str, ct_space));
	2741	+
	2742	+ g.push(s, str - s);
	2743	+ }
	2744	+
	2745	+ while (true)
	2746	+ {
	2747	+ PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr_ws \| ct_space));
	2748	+
	2749	+ if (*s == end_quote)
	2750	+ {
	2751	+ char_t* str = g.flush(s);
	2752	+
	2753	+ do *str-- = 0;
	2754	+ while (PUGI__IS_CHARTYPE(*str, ct_space));
	2755	+
	2756	+ return s + 1;
	2757	+ }
	2758	+ else if (PUGI__IS_CHARTYPE(*s, ct_space))
	2759	+ {
	2760	+ *s++ = ' ';
	2761	+
	2762	+ if (PUGI__IS_CHARTYPE(*s, ct_space))
	2763	+ {
	2764	+ char_t* str = s + 1;
	2765	+ while (PUGI__IS_CHARTYPE(*str, ct_space)) ++str;
	2766	+
	2767	+ g.push(s, str - s);
	2768	+ }
	2769	+ }
	2770	+ else if (opt_escape::value && *s == '&')
	2771	+ {
	2772	+ s = strconv_escape(s, g);
	2773	+ }
	2774	+ else if (!*s)
	2775	+ {
	2776	+ return 0;
	2777	+ }
	2778	+ else ++s;
	2779	+ }
	2780	+ }
	2781	+
	2782	+ static char_t* parse_wconv(char_t* s, char_t end_quote)
	2783	+ {
	2784	+ gap g;
	2785	+
	2786	+ while (true)
	2787	+ {
	2788	+ PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr_ws));
	2789	+
	2790	+ if (*s == end_quote)
	2791	+ {
	2792	+ *g.flush(s) = 0;
	2793	+
	2794	+ return s + 1;
	2795	+ }
	2796	+ else if (PUGI__IS_CHARTYPE(*s, ct_space))
	2797	+ {
	2798	+ if (*s == '\r')
	2799	+ {
	2800	+ *s++ = ' ';
	2801	+
	2802	+ if (*s == '\n') g.push(s, 1);
	2803	+ }
	2804	+ else *s++ = ' ';
	2805	+ }
	2806	+ else if (opt_escape::value && *s == '&')
	2807	+ {
	2808	+ s = strconv_escape(s, g);
	2809	+ }
	2810	+ else if (!*s)
	2811	+ {
	2812	+ return 0;
	2813	+ }
	2814	+ else ++s;
	2815	+ }
	2816	+ }
	2817	+
	2818	+ static char_t* parse_eol(char_t* s, char_t end_quote)
	2819	+ {
	2820	+ gap g;
	2821	+
	2822	+ while (true)
	2823	+ {
	2824	+ PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr));
	2825	+
	2826	+ if (*s == end_quote)
	2827	+ {
	2828	+ *g.flush(s) = 0;
	2829	+
	2830	+ return s + 1;
	2831	+ }
	2832	+ else if (*s == '\r')
	2833	+ {
	2834	+ *s++ = '\n';
	2835	+
	2836	+ if (*s == '\n') g.push(s, 1);
	2837	+ }
	2838	+ else if (opt_escape::value && *s == '&')
	2839	+ {
	2840	+ s = strconv_escape(s, g);
	2841	+ }
	2842	+ else if (!*s)
	2843	+ {
	2844	+ return 0;
	2845	+ }
	2846	+ else ++s;
	2847	+ }
	2848	+ }
	2849	+
	2850	+ static char_t* parse_simple(char_t* s, char_t end_quote)
	2851	+ {
	2852	+ gap g;
	2853	+
	2854	+ while (true)
	2855	+ {
	2856	+ PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPE(ss, ct_parse_attr));
	2857	+
	2858	+ if (*s == end_quote)
	2859	+ {
	2860	+ *g.flush(s) = 0;
	2861	+
	2862	+ return s + 1;
	2863	+ }
	2864	+ else if (opt_escape::value && *s == '&')
	2865	+ {
	2866	+ s = strconv_escape(s, g);
	2867	+ }
	2868	+ else if (!*s)
	2869	+ {
	2870	+ return 0;
	2871	+ }
	2872	+ else ++s;
	2873	+ }
	2874	+ }
	2875	+ };
	2876	+
	2877	+ PUGI__FN strconv_attribute_t get_strconv_attribute(unsigned int optmask)
	2878	+ {
	2879	+ PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_wconv_attribute == 0x40 && parse_wnorm_attribute == 0x80);
	2880	+
	2881	+ switch ((optmask >> 4) & 15) // get bitmask for flags (wnorm wconv eol escapes); this simultaneously checks 4 options from assertion above
	2882	+ {
	2883	+ case 0: return strconv_attribute_impl<opt_false>::parse_simple;
	2884	+ case 1: return strconv_attribute_impl<opt_true>::parse_simple;
	2885	+ case 2: return strconv_attribute_impl<opt_false>::parse_eol;
	2886	+ case 3: return strconv_attribute_impl<opt_true>::parse_eol;
	2887	+ case 4: return strconv_attribute_impl<opt_false>::parse_wconv;
	2888	+ case 5: return strconv_attribute_impl<opt_true>::parse_wconv;
	2889	+ case 6: return strconv_attribute_impl<opt_false>::parse_wconv;
	2890	+ case 7: return strconv_attribute_impl<opt_true>::parse_wconv;
	2891	+ case 8: return strconv_attribute_impl<opt_false>::parse_wnorm;
	2892	+ case 9: return strconv_attribute_impl<opt_true>::parse_wnorm;
	2893	+ case 10: return strconv_attribute_impl<opt_false>::parse_wnorm;
	2894	+ case 11: return strconv_attribute_impl<opt_true>::parse_wnorm;
	2895	+ case 12: return strconv_attribute_impl<opt_false>::parse_wnorm;
	2896	+ case 13: return strconv_attribute_impl<opt_true>::parse_wnorm;
	2897	+ case 14: return strconv_attribute_impl<opt_false>::parse_wnorm;
	2898	+ case 15: return strconv_attribute_impl<opt_true>::parse_wnorm;
	2899	+ default: assert(false); return 0; // unreachable
	2900	+ }
	2901	+ }
	2902	+
	2903	+ inline xml_parse_result make_parse_result(xml_parse_status status, ptrdiff_t offset = 0)
	2904	+ {
	2905	+ xml_parse_result result;
	2906	+ result.status = status;
	2907	+ result.offset = offset;
	2908	+
	2909	+ return result;
	2910	+ }
	2911	+
	2912	+ struct xml_parser
	2913	+ {
	2914	+ xml_allocator* alloc;
	2915	+ char_t* error_offset;
	2916	+ xml_parse_status error_status;
	2917	+
	2918	+ xml_parser(xml_allocator* alloc_): alloc(alloc_), error_offset(0), error_status(status_ok)
	2919	+ {
	2920	+ }
	2921	+
	2922	+ // DOCTYPE consists of nested sections of the following possible types:
	2923	+ // <!-- ... -->, <? ... ?>, "...", '...'
	2924	+ // <![...]]>
	2925	+ // <!...>
	2926	+ // First group can not contain nested groups
	2927	+ // Second group can contain nested groups of the same type
	2928	+ // Third group can contain all other groups
	2929	+ char_t* parse_doctype_primitive(char_t* s)
	2930	+ {
	2931	+ if (s == '"' \|\| s == '\'')
	2932	+ {
	2933	+ // quoted string
	2934	+ char_t ch = *s++;
	2935	+ PUGI__SCANFOR(*s == ch);
	2936	+ if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s);
	2937	+
	2938	+ s++;
	2939	+ }
	2940	+ else if (s[0] == '<' && s[1] == '?')
	2941	+ {
	2942	+ // <? ... ?>
	2943	+ s += 2;
	2944	+ PUGI__SCANFOR(s[0] == '?' && s[1] == '>'); // no need for ENDSWITH because ?> can't terminate proper doctype
	2945	+ if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s);
	2946	+
	2947	+ s += 2;
	2948	+ }
	2949	+ else if (s[0] == '<' && s[1] == '!' && s[2] == '-' && s[3] == '-')
	2950	+ {
	2951	+ s += 4;
	2952	+ PUGI__SCANFOR(s[0] == '-' && s[1] == '-' && s[2] == '>'); // no need for ENDSWITH because --> can't terminate proper doctype
	2953	+ if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s);
	2954	+
	2955	+ s += 3;
	2956	+ }
	2957	+ else PUGI__THROW_ERROR(status_bad_doctype, s);
	2958	+
	2959	+ return s;
	2960	+ }
	2961	+
	2962	+ char_t* parse_doctype_ignore(char_t* s)
	2963	+ {
	2964	+ size_t depth = 0;
	2965	+
	2966	+ assert(s[0] == '<' && s[1] == '!' && s[2] == '[');
	2967	+ s += 3;
	2968	+
	2969	+ while (*s)
	2970	+ {
	2971	+ if (s[0] == '<' && s[1] == '!' && s[2] == '[')
	2972	+ {
	2973	+ // nested ignore section
	2974	+ s += 3;
	2975	+ depth++;
	2976	+ }
	2977	+ else if (s[0] == ']' && s[1] == ']' && s[2] == '>')
	2978	+ {
	2979	+ // ignore section end
	2980	+ s += 3;
	2981	+
	2982	+ if (depth == 0)
	2983	+ return s;
	2984	+
	2985	+ depth--;
	2986	+ }
	2987	+ else s++;
	2988	+ }
	2989	+
	2990	+ PUGI__THROW_ERROR(status_bad_doctype, s);
	2991	+ }
	2992	+
	2993	+ char_t* parse_doctype_group(char_t* s, char_t endch)
	2994	+ {
	2995	+ size_t depth = 0;
	2996	+
	2997	+ assert((s[0] == '<' \|\| s[0] == 0) && s[1] == '!');
	2998	+ s += 2;
	2999	+
	3000	+ while (*s)
	3001	+ {
	3002	+ if (s[0] == '<' && s[1] == '!' && s[2] != '-')
	3003	+ {
	3004	+ if (s[2] == '[')
	3005	+ {
	3006	+ // ignore
	3007	+ s = parse_doctype_ignore(s);
	3008	+ if (!s) return s;
	3009	+ }
	3010	+ else
	3011	+ {
	3012	+ // some control group
	3013	+ s += 2;
	3014	+ depth++;
	3015	+ }
	3016	+ }
	3017	+ else if (s[0] == '<' \|\| s[0] == '"' \|\| s[0] == '\'')
	3018	+ {
	3019	+ // unknown tag (forbidden), or some primitive group
	3020	+ s = parse_doctype_primitive(s);
	3021	+ if (!s) return s;
	3022	+ }
	3023	+ else if (*s == '>')
	3024	+ {
	3025	+ if (depth == 0)
	3026	+ return s;
	3027	+
	3028	+ depth--;
	3029	+ s++;
	3030	+ }
	3031	+ else s++;
	3032	+ }
	3033	+
	3034	+ if (depth != 0 \|\| endch != '>') PUGI__THROW_ERROR(status_bad_doctype, s);
	3035	+
	3036	+ return s;
	3037	+ }
	3038	+
	3039	+ char_t* parse_exclamation(char_t* s, xml_node_struct* cursor, unsigned int optmsk, char_t endch)
	3040	+ {
	3041	+ // parse node contents, starting with exclamation mark
	3042	+ ++s;
	3043	+
	3044	+ if (*s == '-') // '<!-...'
	3045	+ {
	3046	+ ++s;
	3047	+
	3048	+ if (*s == '-') // '<!--...'
	3049	+ {
	3050	+ ++s;
	3051	+
	3052	+ if (PUGI__OPTSET(parse_comments))
	3053	+ {
	3054	+ PUGI__PUSHNODE(node_comment); // Append a new node on the tree.
	3055	+ cursor->value = s; // Save the offset.
	3056	+ }
	3057	+
	3058	+ if (PUGI__OPTSET(parse_eol) && PUGI__OPTSET(parse_comments))
	3059	+ {
	3060	+ s = strconv_comment(s, endch);
	3061	+
	3062	+ if (!s) PUGI__THROW_ERROR(status_bad_comment, cursor->value);
	3063	+ }
	3064	+ else
	3065	+ {
	3066	+ // Scan for terminating '-->'.
	3067	+ PUGI__SCANFOR(s[0] == '-' && s[1] == '-' && PUGI__ENDSWITH(s[2], '>'));
	3068	+ PUGI__CHECK_ERROR(status_bad_comment, s);
	3069	+
	3070	+ if (PUGI__OPTSET(parse_comments))
	3071	+ *s = 0; // Zero-terminate this segment at the first terminating '-'.
	3072	+
	3073	+ s += (s[2] == '>' ? 3 : 2); // Step over the '\0->'.
	3074	+ }
	3075	+ }
	3076	+ else PUGI__THROW_ERROR(status_bad_comment, s);
	3077	+ }
	3078	+ else if (*s == '[')
	3079	+ {
	3080	+ // '<![CDATA[...'
	3081	+ if (++s=='C' && ++s=='D' && ++s=='A' && ++s=='T' && ++s=='A' && ++s == '[')
	3082	+ {
	3083	+ ++s;
	3084	+
	3085	+ if (PUGI__OPTSET(parse_cdata))
	3086	+ {
	3087	+ PUGI__PUSHNODE(node_cdata); // Append a new node on the tree.
	3088	+ cursor->value = s; // Save the offset.
	3089	+
	3090	+ if (PUGI__OPTSET(parse_eol))
	3091	+ {
	3092	+ s = strconv_cdata(s, endch);
	3093	+
	3094	+ if (!s) PUGI__THROW_ERROR(status_bad_cdata, cursor->value);
	3095	+ }
	3096	+ else
	3097	+ {
	3098	+ // Scan for terminating ']]>'.
	3099	+ PUGI__SCANFOR(s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>'));
	3100	+ PUGI__CHECK_ERROR(status_bad_cdata, s);
	3101	+
	3102	+ *s++ = 0; // Zero-terminate this segment.
	3103	+ }
	3104	+ }
	3105	+ else // Flagged for discard, but we still have to scan for the terminator.
	3106	+ {
	3107	+ // Scan for terminating ']]>'.
	3108	+ PUGI__SCANFOR(s[0] == ']' && s[1] == ']' && PUGI__ENDSWITH(s[2], '>'));
	3109	+ PUGI__CHECK_ERROR(status_bad_cdata, s);
	3110	+
	3111	+ ++s;
	3112	+ }
	3113	+
	3114	+ s += (s[1] == '>' ? 2 : 1); // Step over the last ']>'.
	3115	+ }
	3116	+ else PUGI__THROW_ERROR(status_bad_cdata, s);
	3117	+ }
	3118	+ else if (s[0] == 'D' && s[1] == 'O' && s[2] == 'C' && s[3] == 'T' && s[4] == 'Y' && s[5] == 'P' && PUGI__ENDSWITH(s[6], 'E'))
	3119	+ {
	3120	+ s -= 2;
	3121	+
	3122	+ if (cursor->parent) PUGI__THROW_ERROR(status_bad_doctype, s);
	3123	+
	3124	+ char_t* mark = s + 9;
	3125	+
	3126	+ s = parse_doctype_group(s, endch);
	3127	+ if (!s) return s;
	3128	+
	3129	+ assert((s == 0 && endch == '>') \|\| s == '>');
	3130	+ if (s) s++ = 0;
	3131	+
	3132	+ if (PUGI__OPTSET(parse_doctype))
	3133	+ {
	3134	+ while (PUGI__IS_CHARTYPE(*mark, ct_space)) ++mark;
	3135	+
	3136	+ PUGI__PUSHNODE(node_doctype);
	3137	+
	3138	+ cursor->value = mark;
	3139	+ }
	3140	+ }
	3141	+ else if (*s == 0 && endch == '-') PUGI__THROW_ERROR(status_bad_comment, s);
	3142	+ else if (*s == 0 && endch == '[') PUGI__THROW_ERROR(status_bad_cdata, s);
	3143	+ else PUGI__THROW_ERROR(status_unrecognized_tag, s);
	3144	+
	3145	+ return s;
	3146	+ }
	3147	+
	3148	+ char_t* parse_question(char_t* s, xml_node_struct*& ref_cursor, unsigned int optmsk, char_t endch)
	3149	+ {
	3150	+ // load into registers
	3151	+ xml_node_struct* cursor = ref_cursor;
	3152	+ char_t ch = 0;
	3153	+
	3154	+ // parse node contents, starting with question mark
	3155	+ ++s;
	3156	+
	3157	+ // read PI target
	3158	+ char_t* target = s;
	3159	+
	3160	+ if (!PUGI__IS_CHARTYPE(*s, ct_start_symbol)) PUGI__THROW_ERROR(status_bad_pi, s);
	3161	+
	3162	+ PUGI__SCANWHILE(PUGI__IS_CHARTYPE(*s, ct_symbol));
	3163	+ PUGI__CHECK_ERROR(status_bad_pi, s);
	3164	+
	3165	+ // determine node type; stricmp / strcasecmp is not portable
	3166	+ bool declaration = (target[0] \| ' ') == 'x' && (target[1] \| ' ') == 'm' && (target[2] \| ' ') == 'l' && target + 3 == s;
	3167	+
	3168	+ if (declaration ? PUGI__OPTSET(parse_declaration) : PUGI__OPTSET(parse_pi))
	3169	+ {
	3170	+ if (declaration)
	3171	+ {
	3172	+ // disallow non top-level declarations
	3173	+ if (cursor->parent) PUGI__THROW_ERROR(status_bad_pi, s);
	3174	+
	3175	+ PUGI__PUSHNODE(node_declaration);
	3176	+ }
	3177	+ else
	3178	+ {
	3179	+ PUGI__PUSHNODE(node_pi);
	3180	+ }
	3181	+
	3182	+ cursor->name = target;
	3183	+
	3184	+ PUGI__ENDSEG();
	3185	+
	3186	+ // parse value/attributes
	3187	+ if (ch == '?')
	3188	+ {
	3189	+ // empty node
	3190	+ if (!PUGI__ENDSWITH(*s, '>')) PUGI__THROW_ERROR(status_bad_pi, s);
	3191	+ s += (*s == '>');
	3192	+
	3193	+ PUGI__POPNODE();
	3194	+ }
	3195	+ else if (PUGI__IS_CHARTYPE(ch, ct_space))
	3196	+ {
	3197	+ PUGI__SKIPWS();
	3198	+
	3199	+ // scan for tag end
	3200	+ char_t* value = s;
	3201	+
	3202	+ PUGI__SCANFOR(s[0] == '?' && PUGI__ENDSWITH(s[1], '>'));
	3203	+ PUGI__CHECK_ERROR(status_bad_pi, s);
	3204	+
	3205	+ if (declaration)
	3206	+ {
	3207	+ // replace ending ? with / so that 'element' terminates properly
	3208	+ *s = '/';
	3209	+
	3210	+ // we exit from this function with cursor at node_declaration, which is a signal to parse() to go to LOC_ATTRIBUTES
	3211	+ s = value;
	3212	+ }
	3213	+ else
	3214	+ {
	3215	+ // store value and step over >
	3216	+ cursor->value = value;
	3217	+
	3218	+ PUGI__POPNODE();
	3219	+
	3220	+ PUGI__ENDSEG();
	3221	+
	3222	+ s += (*s == '>');
	3223	+ }
	3224	+ }
	3225	+ else PUGI__THROW_ERROR(status_bad_pi, s);
	3226	+ }
	3227	+ else
	3228	+ {
	3229	+ // scan for tag end
	3230	+ PUGI__SCANFOR(s[0] == '?' && PUGI__ENDSWITH(s[1], '>'));
	3231	+ PUGI__CHECK_ERROR(status_bad_pi, s);
	3232	+
	3233	+ s += (s[1] == '>' ? 2 : 1);
	3234	+ }
	3235	+
	3236	+ // store from registers
	3237	+ ref_cursor = cursor;
	3238	+
	3239	+ return s;
	3240	+ }
	3241	+
	3242	+ char_t* parse_tree(char_t* s, xml_node_struct* root, unsigned int optmsk, char_t endch)
	3243	+ {
	3244	+ strconv_attribute_t strconv_attribute = get_strconv_attribute(optmsk);
	3245	+ strconv_pcdata_t strconv_pcdata = get_strconv_pcdata(optmsk);
	3246	+
	3247	+ char_t ch = 0;
	3248	+ xml_node_struct* cursor = root;
	3249	+ char_t* mark = s;
	3250	+
	3251	+ while (*s != 0)
	3252	+ {
	3253	+ if (*s == '<')
	3254	+ {
	3255	+ ++s;
	3256	+
	3257	+ LOC_TAG:
	3258	+ if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // '<#...'
	3259	+ {
	3260	+ PUGI__PUSHNODE(node_element); // Append a new node to the tree.
	3261	+
	3262	+ cursor->name = s;
	3263	+
	3264	+ PUGI__SCANWHILE_UNROLL(PUGI__IS_CHARTYPE(ss, ct_symbol)); // Scan for a terminator.
	3265	+ PUGI__ENDSEG(); // Save char in 'ch', terminate & step over.
	3266	+
	3267	+ if (ch == '>')
	3268	+ {
	3269	+ // end of tag
	3270	+ }
	3271	+ else if (PUGI__IS_CHARTYPE(ch, ct_space))
	3272	+ {
	3273	+ LOC_ATTRIBUTES:
	3274	+ while (true)
	3275	+ {
	3276	+ PUGI__SKIPWS(); // Eat any whitespace.
	3277	+
	3278	+ if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // <... #...
	3279	+ {
	3280	+ xml_attribute_struct* a = append_new_attribute(cursor, *alloc); // Make space for this attribute.
	3281	+ if (!a) PUGI__THROW_ERROR(status_out_of_memory, s);
	3282	+
	3283	+ a->name = s; // Save the offset.
	3284	+
	3285	+ PUGI__SCANWHILE_UNROLL(PUGI__IS_CHARTYPE(ss, ct_symbol)); // Scan for a terminator.
	3286	+ PUGI__ENDSEG(); // Save char in 'ch', terminate & step over.
	3287	+
	3288	+ if (PUGI__IS_CHARTYPE(ch, ct_space))
	3289	+ {
	3290	+ PUGI__SKIPWS(); // Eat any whitespace.
	3291	+
	3292	+ ch = *s;
	3293	+ ++s;
	3294	+ }
	3295	+
	3296	+ if (ch == '=') // '<... #=...'
	3297	+ {
	3298	+ PUGI__SKIPWS(); // Eat any whitespace.
	3299	+
	3300	+ if (s == '"' \|\| s == '\'') // '<... #="...'
	3301	+ {
	3302	+ ch = *s; // Save quote char to avoid breaking on "''" -or- '""'.
	3303	+ ++s; // Step over the quote.
	3304	+ a->value = s; // Save the offset.
	3305	+
	3306	+ s = strconv_attribute(s, ch);
	3307	+
	3308	+ if (!s) PUGI__THROW_ERROR(status_bad_attribute, a->value);
	3309	+
	3310	+ // After this line the loop continues from the start;
	3311	+ // Whitespaces, / and > are ok, symbols and EOF are wrong,
	3312	+ // everything else will be detected
	3313	+ if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) PUGI__THROW_ERROR(status_bad_attribute, s);
	3314	+ }
	3315	+ else PUGI__THROW_ERROR(status_bad_attribute, s);
	3316	+ }
	3317	+ else PUGI__THROW_ERROR(status_bad_attribute, s);
	3318	+ }
	3319	+ else if (*s == '/')
	3320	+ {
	3321	+ ++s;
	3322	+
	3323	+ if (*s == '>')
	3324	+ {
	3325	+ PUGI__POPNODE();
	3326	+ s++;
	3327	+ break;
	3328	+ }
	3329	+ else if (*s == 0 && endch == '>')
	3330	+ {
	3331	+ PUGI__POPNODE();
	3332	+ break;
	3333	+ }
	3334	+ else PUGI__THROW_ERROR(status_bad_start_element, s);
	3335	+ }
	3336	+ else if (*s == '>')
	3337	+ {
	3338	+ ++s;
	3339	+
	3340	+ break;
	3341	+ }
	3342	+ else if (*s == 0 && endch == '>')
	3343	+ {
	3344	+ break;
	3345	+ }
	3346	+ else PUGI__THROW_ERROR(status_bad_start_element, s);
	3347	+ }
	3348	+
	3349	+ // !!!
	3350	+ }
	3351	+ else if (ch == '/') // '<#.../'
	3352	+ {
	3353	+ if (!PUGI__ENDSWITH(*s, '>')) PUGI__THROW_ERROR(status_bad_start_element, s);
	3354	+
	3355	+ PUGI__POPNODE(); // Pop.
	3356	+
	3357	+ s += (*s == '>');
	3358	+ }
	3359	+ else if (ch == 0)
	3360	+ {
	3361	+ // we stepped over null terminator, backtrack & handle closing tag
	3362	+ --s;
	3363	+
	3364	+ if (endch != '>') PUGI__THROW_ERROR(status_bad_start_element, s);
	3365	+ }
	3366	+ else PUGI__THROW_ERROR(status_bad_start_element, s);
	3367	+ }
	3368	+ else if (*s == '/')
	3369	+ {
	3370	+ ++s;
	3371	+
	3372	+ mark = s;
	3373	+
	3374	+ char_t* name = cursor->name;
	3375	+ if (!name) PUGI__THROW_ERROR(status_end_element_mismatch, mark);
	3376	+
	3377	+ while (PUGI__IS_CHARTYPE(*s, ct_symbol))
	3378	+ {
	3379	+ if (s++ != name++) PUGI__THROW_ERROR(status_end_element_mismatch, mark);
	3380	+ }
	3381	+
	3382	+ if (*name)
	3383	+ {
	3384	+ if (*s == 0 && name[0] == endch && name[1] == 0) PUGI__THROW_ERROR(status_bad_end_element, s);
	3385	+ else PUGI__THROW_ERROR(status_end_element_mismatch, mark);
	3386	+ }
	3387	+
	3388	+ PUGI__POPNODE(); // Pop.
	3389	+
	3390	+ PUGI__SKIPWS();
	3391	+
	3392	+ if (*s == 0)
	3393	+ {
	3394	+ if (endch != '>') PUGI__THROW_ERROR(status_bad_end_element, s);
	3395	+ }
	3396	+ else
	3397	+ {
	3398	+ if (*s != '>') PUGI__THROW_ERROR(status_bad_end_element, s);
	3399	+ ++s;
	3400	+ }
	3401	+ }
	3402	+ else if (*s == '?') // '<?...'
	3403	+ {
	3404	+ s = parse_question(s, cursor, optmsk, endch);
	3405	+ if (!s) return s;
	3406	+
	3407	+ assert(cursor);
	3408	+ if (PUGI__NODETYPE(cursor) == node_declaration) goto LOC_ATTRIBUTES;
	3409	+ }
	3410	+ else if (*s == '!') // '<!...'
	3411	+ {
	3412	+ s = parse_exclamation(s, cursor, optmsk, endch);
	3413	+ if (!s) return s;
	3414	+ }
	3415	+ else if (*s == 0 && endch == '?') PUGI__THROW_ERROR(status_bad_pi, s);
	3416	+ else PUGI__THROW_ERROR(status_unrecognized_tag, s);
	3417	+ }
	3418	+ else
	3419	+ {
	3420	+ mark = s; // Save this offset while searching for a terminator.
	3421	+
	3422	+ PUGI__SKIPWS(); // Eat whitespace if no genuine PCDATA here.
	3423	+
	3424	+ if (s == '<' \|\| !s)
	3425	+ {
	3426	+ // We skipped some whitespace characters because otherwise we would take the tag branch instead of PCDATA one
	3427	+ assert(mark != s);
	3428	+
	3429	+ if (!PUGI__OPTSET(parse_ws_pcdata \| parse_ws_pcdata_single) \|\| PUGI__OPTSET(parse_trim_pcdata))
	3430	+ {
	3431	+ continue;
	3432	+ }
	3433	+ else if (PUGI__OPTSET(parse_ws_pcdata_single))
	3434	+ {
	3435	+ if (s[0] != '<' \|\| s[1] != '/' \|\| cursor->first_child) continue;
	3436	+ }
	3437	+ }
	3438	+
	3439	+ if (!PUGI__OPTSET(parse_trim_pcdata))
	3440	+ s = mark;
	3441	+
	3442	+ if (cursor->parent \|\| PUGI__OPTSET(parse_fragment))
	3443	+ {
	3444	+ if (PUGI__OPTSET(parse_embed_pcdata) && cursor->parent && !cursor->first_child && !cursor->value)
	3445	+ {
	3446	+ cursor->value = s; // Save the offset.
	3447	+ }
	3448	+ else
	3449	+ {
	3450	+ PUGI__PUSHNODE(node_pcdata); // Append a new node on the tree.
	3451	+
	3452	+ cursor->value = s; // Save the offset.
	3453	+
	3454	+ PUGI__POPNODE(); // Pop since this is a standalone.
	3455	+ }
	3456	+
	3457	+ s = strconv_pcdata(s);
	3458	+
	3459	+ if (!*s) break;
	3460	+ }
	3461	+ else
	3462	+ {
	3463	+ PUGI__SCANFOR(*s == '<'); // '...<'
	3464	+ if (!*s) break;
	3465	+
	3466	+ ++s;
	3467	+ }
	3468	+
	3469	+ // We're after '<'
	3470	+ goto LOC_TAG;
	3471	+ }
	3472	+ }
	3473	+
	3474	+ // check that last tag is closed
	3475	+ if (cursor != root) PUGI__THROW_ERROR(status_end_element_mismatch, s);
	3476	+
	3477	+ return s;
	3478	+ }
	3479	+
	3480	+ #ifdef PUGIXML_WCHAR_MODE
	3481	+ static char_t* parse_skip_bom(char_t* s)
	3482	+ {
	3483	+ unsigned int bom = 0xfeff;
	3484	+ return (s[0] == static_cast<wchar_t>(bom)) ? s + 1 : s;
	3485	+ }
	3486	+ #else
	3487	+ static char_t* parse_skip_bom(char_t* s)
	3488	+ {
	3489	+ return (s[0] == '\xef' && s[1] == '\xbb' && s[2] == '\xbf') ? s + 3 : s;
	3490	+ }
	3491	+ #endif
	3492	+
	3493	+ static bool has_element_node_siblings(xml_node_struct* node)
	3494	+ {
	3495	+ while (node)
	3496	+ {
	3497	+ if (PUGI__NODETYPE(node) == node_element) return true;
	3498	+
	3499	+ node = node->next_sibling;
	3500	+ }
	3501	+
	3502	+ return false;
	3503	+ }
	3504	+
	3505	+ static xml_parse_result parse(char_t* buffer, size_t length, xml_document_struct* xmldoc, xml_node_struct* root, unsigned int optmsk)
	3506	+ {
	3507	+ // early-out for empty documents
	3508	+ if (length == 0)
	3509	+ return make_parse_result(PUGI__OPTSET(parse_fragment) ? status_ok : status_no_document_element);
	3510	+
	3511	+ // get last child of the root before parsing
	3512	+ xml_node_struct* last_root_child = root->first_child ? root->first_child->prev_sibling_c + 0 : 0;
	3513	+
	3514	+ // create parser on stack
	3515	+ xml_parser parser(static_cast<xml_allocator*>(xmldoc));
	3516	+
	3517	+ // save last character and make buffer zero-terminated (speeds up parsing)
	3518	+ char_t endch = buffer[length - 1];
	3519	+ buffer[length - 1] = 0;
	3520	+
	3521	+ // skip BOM to make sure it does not end up as part of parse output
	3522	+ char_t* buffer_data = parse_skip_bom(buffer);
	3523	+
	3524	+ // perform actual parsing
	3525	+ parser.parse_tree(buffer_data, root, optmsk, endch);
	3526	+
	3527	+ xml_parse_result result = make_parse_result(parser.error_status, parser.error_offset ? parser.error_offset - buffer : 0);
	3528	+ assert(result.offset >= 0 && static_cast<size_t>(result.offset) <= length);
	3529	+
	3530	+ if (result)
	3531	+ {
	3532	+ // since we removed last character, we have to handle the only possible false positive (stray <)
	3533	+ if (endch == '<')
	3534	+ return make_parse_result(status_unrecognized_tag, length - 1);
	3535	+
	3536	+ // check if there are any element nodes parsed
	3537	+ xml_node_struct* first_root_child_parsed = last_root_child ? last_root_child->next_sibling + 0 : root->first_child+ 0;
	3538	+
	3539	+ if (!PUGI__OPTSET(parse_fragment) && !has_element_node_siblings(first_root_child_parsed))
	3540	+ return make_parse_result(status_no_document_element, length - 1);
	3541	+ }
	3542	+ else
	3543	+ {
	3544	+ // roll back offset if it occurs on a null terminator in the source buffer
	3545	+ if (result.offset > 0 && static_cast<size_t>(result.offset) == length - 1 && endch == 0)
	3546	+ result.offset--;
	3547	+ }
	3548	+
	3549	+ return result;
	3550	+ }
	3551	+ };
	3552	+
	3553	+ // Output facilities
	3554	+ PUGI__FN xml_encoding get_write_native_encoding()
	3555	+ {
	3556	+ #ifdef PUGIXML_WCHAR_MODE
	3557	+ return get_wchar_encoding();
	3558	+ #else
	3559	+ return encoding_utf8;
	3560	+ #endif
	3561	+ }
	3562	+
	3563	+ PUGI__FN xml_encoding get_write_encoding(xml_encoding encoding)
	3564	+ {
	3565	+ // replace wchar encoding with utf implementation
	3566	+ if (encoding == encoding_wchar) return get_wchar_encoding();
	3567	+
	3568	+ // replace utf16 encoding with utf16 with specific endianness
	3569	+ if (encoding == encoding_utf16) return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
	3570	+
	3571	+ // replace utf32 encoding with utf32 with specific endianness
	3572	+ if (encoding == encoding_utf32) return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
	3573	+
	3574	+ // only do autodetection if no explicit encoding is requested
	3575	+ if (encoding != encoding_auto) return encoding;
	3576	+
	3577	+ // assume utf8 encoding
	3578	+ return encoding_utf8;
	3579	+ }
	3580	+
	3581	+ template <typename D, typename T> PUGI__FN size_t convert_buffer_output_generic(typename T::value_type dest, const char_t* data, size_t length, D, T)
	3582	+ {
	3583	+ PUGI__STATIC_ASSERT(sizeof(char_t) == sizeof(typename D::type));
	3584	+
	3585	+ typename T::value_type end = D::process(reinterpret_cast<const typename D::type*>(data), length, dest, T());
	3586	+
	3587	+ return static_cast<size_t>(end - dest) * sizeof(*dest);
	3588	+ }
	3589	+
	3590	+ template <typename D, typename T> PUGI__FN size_t convert_buffer_output_generic(typename T::value_type dest, const char_t* data, size_t length, D, T, bool opt_swap)
	3591	+ {
	3592	+ PUGI__STATIC_ASSERT(sizeof(char_t) == sizeof(typename D::type));
	3593	+
	3594	+ typename T::value_type end = D::process(reinterpret_cast<const typename D::type*>(data), length, dest, T());
	3595	+
	3596	+ if (opt_swap)
	3597	+ {
	3598	+ for (typename T::value_type i = dest; i != end; ++i)
	3599	+ i = endian_swap(i);
	3600	+ }
	3601	+
	3602	+ return static_cast<size_t>(end - dest) * sizeof(*dest);
	3603	+ }
	3604	+
	3605	+#ifdef PUGIXML_WCHAR_MODE
	3606	+ PUGI__FN size_t get_valid_length(const char_t* data, size_t length)
	3607	+ {
	3608	+ if (length < 1) return 0;
	3609	+
	3610	+ // discard last character if it's the lead of a surrogate pair
	3611	+ return (sizeof(wchar_t) == 2 && static_cast<unsigned int>(static_cast<uint16_t>(data[length - 1]) - 0xD800) < 0x400) ? length - 1 : length;
	3612	+ }
	3613	+
	3614	+ PUGI__FN size_t convert_buffer_output(char_t* r_char, uint8_t* r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding)
	3615	+ {
	3616	+ // only endian-swapping is required
	3617	+ if (need_endian_swap_utf(encoding, get_wchar_encoding()))
	3618	+ {
	3619	+ convert_wchar_endian_swap(r_char, data, length);
	3620	+
	3621	+ return length * sizeof(char_t);
	3622	+ }
	3623	+
	3624	+ // convert to utf8
	3625	+ if (encoding == encoding_utf8)
	3626	+ return convert_buffer_output_generic(r_u8, data, length, wchar_decoder(), utf8_writer());
	3627	+
	3628	+ // convert to utf16
	3629	+ if (encoding == encoding_utf16_be \|\| encoding == encoding_utf16_le)
	3630	+ {
	3631	+ xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
	3632	+
	3633	+ return convert_buffer_output_generic(r_u16, data, length, wchar_decoder(), utf16_writer(), native_encoding != encoding);
	3634	+ }
	3635	+
	3636	+ // convert to utf32
	3637	+ if (encoding == encoding_utf32_be \|\| encoding == encoding_utf32_le)
	3638	+ {
	3639	+ xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
	3640	+
	3641	+ return convert_buffer_output_generic(r_u32, data, length, wchar_decoder(), utf32_writer(), native_encoding != encoding);
	3642	+ }
	3643	+
	3644	+ // convert to latin1
	3645	+ if (encoding == encoding_latin1)
	3646	+ return convert_buffer_output_generic(r_u8, data, length, wchar_decoder(), latin1_writer());
	3647	+
	3648	+ assert(false && "Invalid encoding"); // unreachable
	3649	+ return 0;
	3650	+ }
	3651	+#else
	3652	+ PUGI__FN size_t get_valid_length(const char_t* data, size_t length)
	3653	+ {
	3654	+ if (length < 5) return 0;
	3655	+
	3656	+ for (size_t i = 1; i <= 4; ++i)
	3657	+ {
	3658	+ uint8_t ch = static_cast<uint8_t>(data[length - i]);
	3659	+
	3660	+ // either a standalone character or a leading one
	3661	+ if ((ch & 0xc0) != 0x80) return length - i;
	3662	+ }
	3663	+
	3664	+ // there are four non-leading characters at the end, sequence tail is broken so might as well process the whole chunk
	3665	+ return length;
	3666	+ }
	3667	+
	3668	+ PUGI__FN size_t convert_buffer_output(char_t* /* r_char /, uint8_t r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding)
	3669	+ {
	3670	+ if (encoding == encoding_utf16_be \|\| encoding == encoding_utf16_le)
	3671	+ {
	3672	+ xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
	3673	+
	3674	+ return convert_buffer_output_generic(r_u16, data, length, utf8_decoder(), utf16_writer(), native_encoding != encoding);
	3675	+ }
	3676	+
	3677	+ if (encoding == encoding_utf32_be \|\| encoding == encoding_utf32_le)
	3678	+ {
	3679	+ xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
	3680	+
	3681	+ return convert_buffer_output_generic(r_u32, data, length, utf8_decoder(), utf32_writer(), native_encoding != encoding);
	3682	+ }
	3683	+
	3684	+ if (encoding == encoding_latin1)
	3685	+ return convert_buffer_output_generic(r_u8, data, length, utf8_decoder(), latin1_writer());
	3686	+
	3687	+ assert(false && "Invalid encoding"); // unreachable
	3688	+ return 0;
	3689	+ }
	3690	+#endif
	3691	+
	3692	+ class xml_buffered_writer
	3693	+ {
	3694	+ xml_buffered_writer(const xml_buffered_writer&);
	3695	+ xml_buffered_writer& operator=(const xml_buffered_writer&);
	3696	+
	3697	+ public:
	3698	+ xml_buffered_writer(xml_writer& writer_, xml_encoding user_encoding): writer(writer_), bufsize(0), encoding(get_write_encoding(user_encoding))
	3699	+ {
	3700	+ PUGI__STATIC_ASSERT(bufcapacity >= 8);
	3701	+ }
	3702	+
	3703	+ size_t flush()
	3704	+ {
	3705	+ flush(buffer, bufsize);
	3706	+ bufsize = 0;
	3707	+ return 0;
	3708	+ }
	3709	+
	3710	+ void flush(const char_t* data, size_t size)
	3711	+ {
	3712	+ if (size == 0) return;
	3713	+
	3714	+ // fast path, just write data
	3715	+ if (encoding == get_write_native_encoding())
	3716	+ writer.write(data, size * sizeof(char_t));
	3717	+ else
	3718	+ {
	3719	+ // convert chunk
	3720	+ size_t result = convert_buffer_output(scratch.data_char, scratch.data_u8, scratch.data_u16, scratch.data_u32, data, size, encoding);
	3721	+ assert(result <= sizeof(scratch));
	3722	+
	3723	+ // write data
	3724	+ writer.write(scratch.data_u8, result);
	3725	+ }
	3726	+ }
	3727	+
	3728	+ void write_direct(const char_t* data, size_t length)
	3729	+ {
	3730	+ // flush the remaining buffer contents
	3731	+ flush();
	3732	+
	3733	+ // handle large chunks
	3734	+ if (length > bufcapacity)
	3735	+ {
	3736	+ if (encoding == get_write_native_encoding())
	3737	+ {
	3738	+ // fast path, can just write data chunk
	3739	+ writer.write(data, length * sizeof(char_t));
	3740	+ return;
	3741	+ }
	3742	+
	3743	+ // need to convert in suitable chunks
	3744	+ while (length > bufcapacity)
	3745	+ {
	3746	+ // get chunk size by selecting such number of characters that are guaranteed to fit into scratch buffer
	3747	+ // and form a complete codepoint sequence (i.e. discard start of last codepoint if necessary)
	3748	+ size_t chunk_size = get_valid_length(data, bufcapacity);
	3749	+ assert(chunk_size);
	3750	+
	3751	+ // convert chunk and write
	3752	+ flush(data, chunk_size);
	3753	+
	3754	+ // iterate
	3755	+ data += chunk_size;
	3756	+ length -= chunk_size;
	3757	+ }
	3758	+
	3759	+ // small tail is copied below
	3760	+ bufsize = 0;
	3761	+ }
	3762	+
	3763	+ memcpy(buffer + bufsize, data, length * sizeof(char_t));
	3764	+ bufsize += length;
	3765	+ }
	3766	+
	3767	+ void write_buffer(const char_t* data, size_t length)
	3768	+ {
	3769	+ size_t offset = bufsize;
	3770	+
	3771	+ if (offset + length <= bufcapacity)
	3772	+ {
	3773	+ memcpy(buffer + offset, data, length * sizeof(char_t));
	3774	+ bufsize = offset + length;
	3775	+ }
	3776	+ else
	3777	+ {
	3778	+ write_direct(data, length);
	3779	+ }
	3780	+ }
	3781	+
	3782	+ void write_string(const char_t* data)
	3783	+ {
	3784	+ // write the part of the string that fits in the buffer
	3785	+ size_t offset = bufsize;
	3786	+
	3787	+ while (*data && offset < bufcapacity)
	3788	+ buffer[offset++] = *data++;
	3789	+
	3790	+ // write the rest
	3791	+ if (offset < bufcapacity)
	3792	+ {
	3793	+ bufsize = offset;
	3794	+ }
	3795	+ else
	3796	+ {
	3797	+ // backtrack a bit if we have split the codepoint
	3798	+ size_t length = offset - bufsize;
	3799	+ size_t extra = length - get_valid_length(data - length, length);
	3800	+
	3801	+ bufsize = offset - extra;
	3802	+
	3803	+ write_direct(data - extra, strlength(data) + extra);
	3804	+ }
	3805	+ }
	3806	+
	3807	+ void write(char_t d0)
	3808	+ {
	3809	+ size_t offset = bufsize;
	3810	+ if (offset > bufcapacity - 1) offset = flush();
	3811	+
	3812	+ buffer[offset + 0] = d0;
	3813	+ bufsize = offset + 1;
	3814	+ }
	3815	+
	3816	+ void write(char_t d0, char_t d1)
	3817	+ {
	3818	+ size_t offset = bufsize;
	3819	+ if (offset > bufcapacity - 2) offset = flush();
	3820	+
	3821	+ buffer[offset + 0] = d0;
	3822	+ buffer[offset + 1] = d1;
	3823	+ bufsize = offset + 2;
	3824	+ }
	3825	+
	3826	+ void write(char_t d0, char_t d1, char_t d2)
	3827	+ {
	3828	+ size_t offset = bufsize;
	3829	+ if (offset > bufcapacity - 3) offset = flush();
	3830	+
	3831	+ buffer[offset + 0] = d0;
	3832	+ buffer[offset + 1] = d1;
	3833	+ buffer[offset + 2] = d2;
	3834	+ bufsize = offset + 3;
	3835	+ }
	3836	+
	3837	+ void write(char_t d0, char_t d1, char_t d2, char_t d3)
	3838	+ {
	3839	+ size_t offset = bufsize;
	3840	+ if (offset > bufcapacity - 4) offset = flush();
	3841	+
	3842	+ buffer[offset + 0] = d0;
	3843	+ buffer[offset + 1] = d1;
	3844	+ buffer[offset + 2] = d2;
	3845	+ buffer[offset + 3] = d3;
	3846	+ bufsize = offset + 4;
	3847	+ }
	3848	+
	3849	+ void write(char_t d0, char_t d1, char_t d2, char_t d3, char_t d4)
	3850	+ {
	3851	+ size_t offset = bufsize;
	3852	+ if (offset > bufcapacity - 5) offset = flush();
	3853	+
	3854	+ buffer[offset + 0] = d0;
	3855	+ buffer[offset + 1] = d1;
	3856	+ buffer[offset + 2] = d2;
	3857	+ buffer[offset + 3] = d3;
	3858	+ buffer[offset + 4] = d4;
	3859	+ bufsize = offset + 5;
	3860	+ }
	3861	+
	3862	+ void write(char_t d0, char_t d1, char_t d2, char_t d3, char_t d4, char_t d5)
	3863	+ {
	3864	+ size_t offset = bufsize;
	3865	+ if (offset > bufcapacity - 6) offset = flush();
	3866	+
	3867	+ buffer[offset + 0] = d0;
	3868	+ buffer[offset + 1] = d1;
	3869	+ buffer[offset + 2] = d2;
	3870	+ buffer[offset + 3] = d3;
	3871	+ buffer[offset + 4] = d4;
	3872	+ buffer[offset + 5] = d5;
	3873	+ bufsize = offset + 6;
	3874	+ }
	3875	+
	3876	+ // utf8 maximum expansion: x4 (-> utf32)
	3877	+ // utf16 maximum expansion: x2 (-> utf32)
	3878	+ // utf32 maximum expansion: x1
	3879	+ enum
	3880	+ {
	3881	+ bufcapacitybytes =
	3882	+ #ifdef PUGIXML_MEMORY_OUTPUT_STACK
	3883	+ PUGIXML_MEMORY_OUTPUT_STACK
	3884	+ #else
	3885	+ 10240
	3886	+ #endif
	3887	+ ,
	3888	+ bufcapacity = bufcapacitybytes / (sizeof(char_t) + 4)
	3889	+ };
	3890	+
	3891	+ char_t buffer[bufcapacity];
	3892	+
	3893	+ union
	3894	+ {
	3895	+ uint8_t data_u8[4 * bufcapacity];
	3896	+ uint16_t data_u16[2 * bufcapacity];
	3897	+ uint32_t data_u32[bufcapacity];
	3898	+ char_t data_char[bufcapacity];
	3899	+ } scratch;
	3900	+
	3901	+ xml_writer& writer;
	3902	+ size_t bufsize;
	3903	+ xml_encoding encoding;
	3904	+ };
	3905	+
	3906	+ PUGI__FN void text_output_escaped(xml_buffered_writer& writer, const char_t* s, chartypex_t type, unsigned int flags)
	3907	+ {
	3908	+ while (*s)
	3909	+ {
	3910	+ const char_t* prev = s;
	3911	+
	3912	+ // While *s is a usual symbol
	3913	+ PUGI__SCANWHILE_UNROLL(!PUGI__IS_CHARTYPEX(ss, type));
	3914	+
	3915	+ writer.write_buffer(prev, static_cast<size_t>(s - prev));
	3916	+
	3917	+ switch (*s)
	3918	+ {
	3919	+ case 0: break;
	3920	+ case '&':
	3921	+ writer.write('&', 'a', 'm', 'p', ';');
	3922	+ ++s;
	3923	+ break;
	3924	+ case '<':
	3925	+ writer.write('&', 'l', 't', ';');
	3926	+ ++s;
	3927	+ break;
	3928	+ case '>':
	3929	+ writer.write('&', 'g', 't', ';');
	3930	+ ++s;
	3931	+ break;
	3932	+ case '"':
	3933	+ if (flags & format_attribute_single_quote)
	3934	+ writer.write('"');
	3935	+ else
	3936	+ writer.write('&', 'q', 'u', 'o', 't', ';');
	3937	+ ++s;
	3938	+ break;
	3939	+ case '\'':
	3940	+ if (flags & format_attribute_single_quote)
	3941	+ writer.write('&', 'a', 'p', 'o', 's', ';');
	3942	+ else
	3943	+ writer.write('\'');
	3944	+ ++s;
	3945	+ break;
	3946	+ default: // s is not a usual symbol
	3947	+ {
	3948	+ unsigned int ch = static_cast<unsigned int>(*s++);
	3949	+ assert(ch < 32);
	3950	+
	3951	+ if (!(flags & format_skip_control_chars))
	3952	+ writer.write('&', '#', static_cast<char_t>((ch / 10) + '0'), static_cast<char_t>((ch % 10) + '0'), ';');
	3953	+ }
	3954	+ }
	3955	+ }
	3956	+ }
	3957	+
	3958	+ PUGI__FN void text_output(xml_buffered_writer& writer, const char_t* s, chartypex_t type, unsigned int flags)
	3959	+ {
	3960	+ if (flags & format_no_escapes)
	3961	+ writer.write_string(s);
	3962	+ else
	3963	+ text_output_escaped(writer, s, type, flags);
	3964	+ }
	3965	+
	3966	+ PUGI__FN void text_output_cdata(xml_buffered_writer& writer, const char_t* s)
	3967	+ {
	3968	+ do
	3969	+ {
	3970	+ writer.write('<', '!', '[', 'C', 'D');
	3971	+ writer.write('A', 'T', 'A', '[');
	3972	+
	3973	+ const char_t* prev = s;
	3974	+
	3975	+ // look for ]]> sequence - we can't output it as is since it terminates CDATA
	3976	+ while (*s && !(s[0] == ']' && s[1] == ']' && s[2] == '>')) ++s;
	3977	+
	3978	+ // skip ]] if we stopped at ]]>, > will go to the next CDATA section
	3979	+ if (*s) s += 2;
	3980	+
	3981	+ writer.write_buffer(prev, static_cast<size_t>(s - prev));
	3982	+
	3983	+ writer.write(']', ']', '>');
	3984	+ }
	3985	+ while (*s);
	3986	+ }
	3987	+
	3988	+ PUGI__FN void text_output_indent(xml_buffered_writer& writer, const char_t* indent, size_t indent_length, unsigned int depth)
	3989	+ {
	3990	+ switch (indent_length)
	3991	+ {
	3992	+ case 1:
	3993	+ {
	3994	+ for (unsigned int i = 0; i < depth; ++i)
	3995	+ writer.write(indent[0]);
	3996	+ break;
	3997	+ }
	3998	+
	3999	+ case 2:
	4000	+ {
	4001	+ for (unsigned int i = 0; i < depth; ++i)
	4002	+ writer.write(indent[0], indent[1]);
	4003	+ break;
	4004	+ }
	4005	+
	4006	+ case 3:
	4007	+ {
	4008	+ for (unsigned int i = 0; i < depth; ++i)
	4009	+ writer.write(indent[0], indent[1], indent[2]);
	4010	+ break;
	4011	+ }
	4012	+
	4013	+ case 4:
	4014	+ {
	4015	+ for (unsigned int i = 0; i < depth; ++i)
	4016	+ writer.write(indent[0], indent[1], indent[2], indent[3]);
	4017	+ break;
	4018	+ }
	4019	+
	4020	+ default:
	4021	+ {
	4022	+ for (unsigned int i = 0; i < depth; ++i)
	4023	+ writer.write_buffer(indent, indent_length);
	4024	+ }
	4025	+ }
	4026	+ }
	4027	+
	4028	+ PUGI__FN void node_output_comment(xml_buffered_writer& writer, const char_t* s)
	4029	+ {
	4030	+ writer.write('<', '!', '-', '-');
	4031	+
	4032	+ while (*s)
	4033	+ {
	4034	+ const char_t* prev = s;
	4035	+
	4036	+ // look for -\0 or -- sequence - we can't output it since -- is illegal in comment body
	4037	+ while (*s && !(s[0] == '-' && (s[1] == '-' \|\| s[1] == 0))) ++s;
	4038	+
	4039	+ writer.write_buffer(prev, static_cast<size_t>(s - prev));
	4040	+
	4041	+ if (*s)
	4042	+ {
	4043	+ assert(*s == '-');
	4044	+
	4045	+ writer.write('-', ' ');
	4046	+ ++s;
	4047	+ }
	4048	+ }
	4049	+
	4050	+ writer.write('-', '-', '>');
	4051	+ }
	4052	+
	4053	+ PUGI__FN void node_output_pi_value(xml_buffered_writer& writer, const char_t* s)
	4054	+ {
	4055	+ while (*s)
	4056	+ {
	4057	+ const char_t* prev = s;
	4058	+
	4059	+ // look for ?> sequence - we can't output it since ?> terminates PI
	4060	+ while (*s && !(s[0] == '?' && s[1] == '>')) ++s;
	4061	+
	4062	+ writer.write_buffer(prev, static_cast<size_t>(s - prev));
	4063	+
	4064	+ if (*s)
	4065	+ {
	4066	+ assert(s[0] == '?' && s[1] == '>');
	4067	+
	4068	+ writer.write('?', ' ', '>');
	4069	+ s += 2;
	4070	+ }
	4071	+ }
	4072	+ }
	4073	+
	4074	+ 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)
	4075	+ {
	4076	+ const char_t* default_name = PUGIXML_TEXT(":anonymous");
	4077	+ const char_t enquotation_char = (flags & format_attribute_single_quote) ? '\'' : '"';
	4078	+
	4079	+ for (xml_attribute_struct* a = node->first_attribute; a; a = a->next_attribute)
	4080	+ {
	4081	+ if ((flags & (format_indent_attributes \| format_raw)) == format_indent_attributes)
	4082	+ {
	4083	+ writer.write('\n');
	4084	+
	4085	+ text_output_indent(writer, indent, indent_length, depth + 1);
	4086	+ }
	4087	+ else
	4088	+ {
	4089	+ writer.write(' ');
	4090	+ }
	4091	+
	4092	+ writer.write_string(a->name ? a->name + 0 : default_name);
	4093	+ writer.write('=', enquotation_char);
	4094	+
	4095	+ if (a->value)
	4096	+ text_output(writer, a->value, ctx_special_attr, flags);
	4097	+
	4098	+ writer.write(enquotation_char);
	4099	+ }
	4100	+ }
	4101	+
	4102	+ 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)
	4103	+ {
	4104	+ const char_t* default_name = PUGIXML_TEXT(":anonymous");
	4105	+ const char_t* name = node->name ? node->name + 0 : default_name;
	4106	+
	4107	+ writer.write('<');
	4108	+ writer.write_string(name);
	4109	+
	4110	+ if (node->first_attribute)
	4111	+ node_output_attributes(writer, node, indent, indent_length, flags, depth);
	4112	+
	4113	+ // element nodes can have value if parse_embed_pcdata was used
	4114	+ if (!node->value)
	4115	+ {
	4116	+ if (!node->first_child)
	4117	+ {
	4118	+ if (flags & format_no_empty_element_tags)
	4119	+ {
	4120	+ writer.write('>', '<', '/');
	4121	+ writer.write_string(name);
	4122	+ writer.write('>');
	4123	+
	4124	+ return false;
	4125	+ }
	4126	+ else
	4127	+ {
	4128	+ if ((flags & format_raw) == 0)
	4129	+ writer.write(' ');
	4130	+
	4131	+ writer.write('/', '>');
	4132	+
	4133	+ return false;
	4134	+ }
	4135	+ }
	4136	+ else
	4137	+ {
	4138	+ writer.write('>');
	4139	+
	4140	+ return true;
	4141	+ }
	4142	+ }
	4143	+ else
	4144	+ {
	4145	+ writer.write('>');
	4146	+
	4147	+ text_output(writer, node->value, ctx_special_pcdata, flags);
	4148	+
	4149	+ if (!node->first_child)
	4150	+ {
	4151	+ writer.write('<', '/');
	4152	+ writer.write_string(name);
	4153	+ writer.write('>');
	4154	+
	4155	+ return false;
	4156	+ }
	4157	+ else
	4158	+ {
	4159	+ return true;
	4160	+ }
	4161	+ }
	4162	+ }
	4163	+
	4164	+ PUGI__FN void node_output_end(xml_buffered_writer& writer, xml_node_struct* node)
	4165	+ {
	4166	+ const char_t* default_name = PUGIXML_TEXT(":anonymous");
	4167	+ const char_t* name = node->name ? node->name + 0 : default_name;
	4168	+
	4169	+ writer.write('<', '/');
	4170	+ writer.write_string(name);
	4171	+ writer.write('>');
	4172	+ }
	4173	+
	4174	+ PUGI__FN void node_output_simple(xml_buffered_writer& writer, xml_node_struct* node, unsigned int flags)
	4175	+ {
	4176	+ const char_t* default_name = PUGIXML_TEXT(":anonymous");
	4177	+
	4178	+ switch (PUGI__NODETYPE(node))
	4179	+ {
	4180	+ case node_pcdata:
	4181	+ text_output(writer, node->value ? node->value + 0 : PUGIXML_TEXT(""), ctx_special_pcdata, flags);
	4182	+ break;
	4183	+
	4184	+ case node_cdata:
	4185	+ text_output_cdata(writer, node->value ? node->value + 0 : PUGIXML_TEXT(""));
	4186	+ break;
	4187	+
	4188	+ case node_comment:
	4189	+ node_output_comment(writer, node->value ? node->value + 0 : PUGIXML_TEXT(""));
	4190	+ break;
	4191	+
	4192	+ case node_pi:
	4193	+ writer.write('<', '?');
	4194	+ writer.write_string(node->name ? node->name + 0 : default_name);
	4195	+
	4196	+ if (node->value)
	4197	+ {
	4198	+ writer.write(' ');
	4199	+ node_output_pi_value(writer, node->value);
	4200	+ }
	4201	+
	4202	+ writer.write('?', '>');
	4203	+ break;
	4204	+
	4205	+ case node_declaration:
	4206	+ writer.write('<', '?');
	4207	+ writer.write_string(node->name ? node->name + 0 : default_name);
	4208	+ node_output_attributes(writer, node, PUGIXML_TEXT(""), 0, flags \| format_raw, 0);
	4209	+ writer.write('?', '>');
	4210	+ break;
	4211	+
	4212	+ case node_doctype:
	4213	+ writer.write('<', '!', 'D', 'O', 'C');
	4214	+ writer.write('T', 'Y', 'P', 'E');
	4215	+
	4216	+ if (node->value)
	4217	+ {
	4218	+ writer.write(' ');
	4219	+ writer.write_string(node->value);
	4220	+ }
	4221	+
	4222	+ writer.write('>');
	4223	+ break;
	4224	+
	4225	+ default:
	4226	+ assert(false && "Invalid node type"); // unreachable
	4227	+ }
	4228	+ }
	4229	+
	4230	+ enum indent_flags_t
	4231	+ {
	4232	+ indent_newline = 1,
	4233	+ indent_indent = 2
	4234	+ };
	4235	+
	4236	+ PUGI__FN void node_output(xml_buffered_writer& writer, xml_node_struct* root, const char_t* indent, unsigned int flags, unsigned int depth)
	4237	+ {
	4238	+ size_t indent_length = ((flags & (format_indent \| format_indent_attributes)) && (flags & format_raw) == 0) ? strlength(indent) : 0;
	4239	+ unsigned int indent_flags = indent_indent;
	4240	+
	4241	+ xml_node_struct* node = root;
	4242	+
	4243	+ do
	4244	+ {
	4245	+ assert(node);
	4246	+
	4247	+ // begin writing current node
	4248	+ if (PUGI__NODETYPE(node) == node_pcdata \|\| PUGI__NODETYPE(node) == node_cdata)
	4249	+ {
	4250	+ node_output_simple(writer, node, flags);
	4251	+
	4252	+ indent_flags = 0;
	4253	+ }
	4254	+ else
	4255	+ {
	4256	+ if ((indent_flags & indent_newline) && (flags & format_raw) == 0)
	4257	+ writer.write('\n');
	4258	+
	4259	+ if ((indent_flags & indent_indent) && indent_length)
	4260	+ text_output_indent(writer, indent, indent_length, depth);
	4261	+
	4262	+ if (PUGI__NODETYPE(node) == node_element)
	4263	+ {
	4264	+ indent_flags = indent_newline \| indent_indent;
	4265	+
	4266	+ if (node_output_start(writer, node, indent, indent_length, flags, depth))
	4267	+ {
	4268	+ // element nodes can have value if parse_embed_pcdata was used
	4269	+ if (node->value)
	4270	+ indent_flags = 0;
	4271	+
	4272	+ node = node->first_child;
	4273	+ depth++;
	4274	+ continue;
	4275	+ }
	4276	+ }
	4277	+ else if (PUGI__NODETYPE(node) == node_document)
	4278	+ {
	4279	+ indent_flags = indent_indent;
	4280	+
	4281	+ if (node->first_child)
	4282	+ {
	4283	+ node = node->first_child;
	4284	+ continue;
	4285	+ }
	4286	+ }
	4287	+ else
	4288	+ {
	4289	+ node_output_simple(writer, node, flags);
	4290	+
	4291	+ indent_flags = indent_newline \| indent_indent;
	4292	+ }
	4293	+ }
	4294	+
	4295	+ // continue to the next node
	4296	+ while (node != root)
	4297	+ {
	4298	+ if (node->next_sibling)
	4299	+ {
	4300	+ node = node->next_sibling;
	4301	+ break;
	4302	+ }
	4303	+
	4304	+ node = node->parent;
	4305	+
	4306	+ // write closing node
	4307	+ if (PUGI__NODETYPE(node) == node_element)
	4308	+ {
	4309	+ depth--;
	4310	+
	4311	+ if ((indent_flags & indent_newline) && (flags & format_raw) == 0)
	4312	+ writer.write('\n');
	4313	+
	4314	+ if ((indent_flags & indent_indent) && indent_length)
	4315	+ text_output_indent(writer, indent, indent_length, depth);
	4316	+
	4317	+ node_output_end(writer, node);
	4318	+
	4319	+ indent_flags = indent_newline \| indent_indent;
	4320	+ }
	4321	+ }
	4322	+ }
	4323	+ while (node != root);
	4324	+
	4325	+ if ((indent_flags & indent_newline) && (flags & format_raw) == 0)
	4326	+ writer.write('\n');
	4327	+ }
	4328	+
	4329	+ PUGI__FN bool has_declaration(xml_node_struct* node)
	4330	+ {
	4331	+ for (xml_node_struct* child = node->first_child; child; child = child->next_sibling)
	4332	+ {
	4333	+ xml_node_type type = PUGI__NODETYPE(child);
	4334	+
	4335	+ if (type == node_declaration) return true;
	4336	+ if (type == node_element) return false;
	4337	+ }
	4338	+
	4339	+ return false;
	4340	+ }
	4341	+
	4342	+ PUGI__FN bool is_attribute_of(xml_attribute_struct* attr, xml_node_struct* node)
	4343	+ {
	4344	+ for (xml_attribute_struct* a = node->first_attribute; a; a = a->next_attribute)
	4345	+ if (a == attr)
	4346	+ return true;
	4347	+
	4348	+ return false;
	4349	+ }
	4350	+
	4351	+ PUGI__FN bool allow_insert_attribute(xml_node_type parent)
	4352	+ {
	4353	+ return parent == node_element \|\| parent == node_declaration;
	4354	+ }
	4355	+
	4356	+ PUGI__FN bool allow_insert_child(xml_node_type parent, xml_node_type child)
	4357	+ {
	4358	+ if (parent != node_document && parent != node_element) return false;
	4359	+ if (child == node_document \|\| child == node_null) return false;
	4360	+ if (parent != node_document && (child == node_declaration \|\| child == node_doctype)) return false;
	4361	+
	4362	+ return true;
	4363	+ }
	4364	+
	4365	+ PUGI__FN bool allow_move(xml_node parent, xml_node child)
	4366	+ {
	4367	+ // check that child can be a child of parent
	4368	+ if (!allow_insert_child(parent.type(), child.type()))
	4369	+ return false;
	4370	+
	4371	+ // check that node is not moved between documents
	4372	+ if (parent.root() != child.root())
	4373	+ return false;
	4374	+
	4375	+ // check that new parent is not in the child subtree
	4376	+ xml_node cur = parent;
	4377	+
	4378	+ while (cur)
	4379	+ {
	4380	+ if (cur == child)
	4381	+ return false;
	4382	+
	4383	+ cur = cur.parent();
	4384	+ }
	4385	+
	4386	+ return true;
	4387	+ }
	4388	+
	4389	+ template <typename String, typename Header>
	4390	+ PUGI__FN void node_copy_string(String& dest, Header& header, uintptr_t header_mask, char_t* source, Header& source_header, xml_allocator* alloc)
	4391	+ {
	4392	+ assert(!dest && (header & header_mask) == 0);
	4393	+
	4394	+ if (source)
	4395	+ {
	4396	+ if (alloc && (source_header & header_mask) == 0)
	4397	+ {
	4398	+ dest = source;
	4399	+
	4400	+ // since strcpy_insitu can reuse document buffer memory we need to mark both source and dest as shared
	4401	+ header \|= xml_memory_page_contents_shared_mask;
	4402	+ source_header \|= xml_memory_page_contents_shared_mask;
	4403	+ }
	4404	+ else
	4405	+ strcpy_insitu(dest, header, header_mask, source, strlength(source));
	4406	+ }
	4407	+ }
	4408	+
	4409	+ PUGI__FN void node_copy_contents(xml_node_struct* dn, xml_node_struct* sn, xml_allocator* shared_alloc)
	4410	+ {
	4411	+ node_copy_string(dn->name, dn->header, xml_memory_page_name_allocated_mask, sn->name, sn->header, shared_alloc);
	4412	+ node_copy_string(dn->value, dn->header, xml_memory_page_value_allocated_mask, sn->value, sn->header, shared_alloc);
	4413	+
	4414	+ for (xml_attribute_struct* sa = sn->first_attribute; sa; sa = sa->next_attribute)
	4415	+ {
	4416	+ xml_attribute_struct* da = append_new_attribute(dn, get_allocator(dn));
	4417	+
	4418	+ if (da)
	4419	+ {
	4420	+ node_copy_string(da->name, da->header, xml_memory_page_name_allocated_mask, sa->name, sa->header, shared_alloc);
	4421	+ node_copy_string(da->value, da->header, xml_memory_page_value_allocated_mask, sa->value, sa->header, shared_alloc);
	4422	+ }
	4423	+ }
	4424	+ }
	4425	+
	4426	+ PUGI__FN void node_copy_tree(xml_node_struct* dn, xml_node_struct* sn)
	4427	+ {
	4428	+ xml_allocator& alloc = get_allocator(dn);
	4429	+ xml_allocator* shared_alloc = (&alloc == &get_allocator(sn)) ? &alloc : 0;
	4430	+
	4431	+ node_copy_contents(dn, sn, shared_alloc);
	4432	+
	4433	+ xml_node_struct* dit = dn;
	4434	+ xml_node_struct* sit = sn->first_child;
	4435	+
	4436	+ while (sit && sit != sn)
	4437	+ {
	4438	+ // loop invariant: dit is inside the subtree rooted at dn
	4439	+ assert(dit);
	4440	+
	4441	+ // when a tree is copied into one of the descendants, we need to skip that subtree to avoid an infinite loop
	4442	+ if (sit != dn)
	4443	+ {
	4444	+ xml_node_struct* copy = append_new_node(dit, alloc, PUGI__NODETYPE(sit));
	4445	+
	4446	+ if (copy)
	4447	+ {
	4448	+ node_copy_contents(copy, sit, shared_alloc);
	4449	+
	4450	+ if (sit->first_child)
	4451	+ {
	4452	+ dit = copy;
	4453	+ sit = sit->first_child;
	4454	+ continue;
	4455	+ }
	4456	+ }
	4457	+ }
	4458	+
	4459	+ // continue to the next node
	4460	+ do
	4461	+ {
	4462	+ if (sit->next_sibling)
	4463	+ {
	4464	+ sit = sit->next_sibling;
	4465	+ break;
	4466	+ }
	4467	+
	4468	+ sit = sit->parent;
	4469	+ dit = dit->parent;
	4470	+
	4471	+ // loop invariant: dit is inside the subtree rooted at dn while sit is inside sn
	4472	+ assert(sit == sn \|\| dit);
	4473	+ }
	4474	+ while (sit != sn);
	4475	+ }
	4476	+
	4477	+ assert(!sit \|\| dit == dn->parent);
	4478	+ }
	4479	+
	4480	+ PUGI__FN void node_copy_attribute(xml_attribute_struct* da, xml_attribute_struct* sa)
	4481	+ {
	4482	+ xml_allocator& alloc = get_allocator(da);
	4483	+ xml_allocator* shared_alloc = (&alloc == &get_allocator(sa)) ? &alloc : 0;
	4484	+
	4485	+ node_copy_string(da->name, da->header, xml_memory_page_name_allocated_mask, sa->name, sa->header, shared_alloc);
	4486	+ node_copy_string(da->value, da->header, xml_memory_page_value_allocated_mask, sa->value, sa->header, shared_alloc);
	4487	+ }
	4488	+
	4489	+ inline bool is_text_node(xml_node_struct* node)
	4490	+ {
	4491	+ xml_node_type type = PUGI__NODETYPE(node);
	4492	+
	4493	+ return type == node_pcdata \|\| type == node_cdata;
	4494	+ }
	4495	+
	4496	+ // get value with conversion functions
	4497	+ template <typename U> PUGI__FN PUGI__UNSIGNED_OVERFLOW U string_to_integer(const char_t* value, U minv, U maxv)
	4498	+ {
	4499	+ U result = 0;
	4500	+ const char_t* s = value;
	4501	+
	4502	+ while (PUGI__IS_CHARTYPE(*s, ct_space))
	4503	+ s++;
	4504	+
	4505	+ bool negative = (*s == '-');
	4506	+
	4507	+ s += (s == '+' \|\| s == '-');
	4508	+
	4509	+ bool overflow = false;
	4510	+
	4511	+ if (s[0] == '0' && (s[1] \| ' ') == 'x')
	4512	+ {
	4513	+ s += 2;
	4514	+
	4515	+ // since overflow detection relies on length of the sequence skip leading zeros
	4516	+ while (*s == '0')
	4517	+ s++;
	4518	+
	4519	+ const char_t* start = s;
	4520	+
	4521	+ for (;;)
	4522	+ {
	4523	+ if (static_cast<unsigned>(*s - '0') < 10)
	4524	+ result = result * 16 + (*s - '0');
	4525	+ else if (static_cast<unsigned>((*s \| ' ') - 'a') < 6)
	4526	+ result = result * 16 + ((*s \| ' ') - 'a' + 10);
	4527	+ else
	4528	+ break;
	4529	+
	4530	+ s++;
	4531	+ }
	4532	+
	4533	+ size_t digits = static_cast<size_t>(s - start);
	4534	+
	4535	+ overflow = digits > sizeof(U) * 2;
	4536	+ }
	4537	+ else
	4538	+ {
	4539	+ // since overflow detection relies on length of the sequence skip leading zeros
	4540	+ while (*s == '0')
	4541	+ s++;
	4542	+
	4543	+ const char_t* start = s;
	4544	+
	4545	+ for (;;)
	4546	+ {
	4547	+ if (static_cast<unsigned>(*s - '0') < 10)
	4548	+ result = result * 10 + (*s - '0');
	4549	+ else
	4550	+ break;
	4551	+
	4552	+ s++;
	4553	+ }
	4554	+
	4555	+ size_t digits = static_cast<size_t>(s - start);
	4556	+
	4557	+ PUGI__STATIC_ASSERT(sizeof(U) == 8 \|\| sizeof(U) == 4 \|\| sizeof(U) == 2);
	4558	+
	4559	+ const size_t max_digits10 = sizeof(U) == 8 ? 20 : sizeof(U) == 4 ? 10 : 5;
	4560	+ const char_t max_lead = sizeof(U) == 8 ? '1' : sizeof(U) == 4 ? '4' : '6';
	4561	+ const size_t high_bit = sizeof(U) * 8 - 1;
	4562	+
	4563	+ overflow = digits >= max_digits10 && !(digits == max_digits10 && (start < max_lead \|\| (start == max_lead && result >> high_bit)));
	4564	+ }
	4565	+
	4566	+ if (negative)
	4567	+ {
	4568	+ // Workaround for crayc++ CC-3059: Expected no overflow in routine.
	4569	+ #ifdef _CRAYC
	4570	+ return (overflow \|\| result > ~minv + 1) ? minv : ~result + 1;
	4571	+ #else
	4572	+ return (overflow \|\| result > 0 - minv) ? minv : 0 - result;
	4573	+ #endif
	4574	+ }
	4575	+ else
	4576	+ return (overflow \|\| result > maxv) ? maxv : result;
	4577	+ }
	4578	+
	4579	+ PUGI__FN int get_value_int(const char_t* value)
	4580	+ {
	4581	+ return string_to_integer<unsigned int>(value, static_cast<unsigned int>(INT_MIN), INT_MAX);
	4582	+ }
	4583	+
	4584	+ PUGI__FN unsigned int get_value_uint(const char_t* value)
	4585	+ {
	4586	+ return string_to_integer<unsigned int>(value, 0, UINT_MAX);
	4587	+ }
	4588	+
	4589	+ PUGI__FN double get_value_double(const char_t* value)
	4590	+ {
	4591	+ #ifdef PUGIXML_WCHAR_MODE
	4592	+ return wcstod(value, 0);
	4593	+ #else
	4594	+ return strtod(value, 0);
	4595	+ #endif
	4596	+ }
	4597	+
	4598	+ PUGI__FN float get_value_float(const char_t* value)
	4599	+ {
	4600	+ #ifdef PUGIXML_WCHAR_MODE
	4601	+ return static_cast<float>(wcstod(value, 0));
	4602	+ #else
	4603	+ return static_cast<float>(strtod(value, 0));
	4604	+ #endif
	4605	+ }
	4606	+
	4607	+ PUGI__FN bool get_value_bool(const char_t* value)
	4608	+ {
	4609	+ // only look at first char
	4610	+ char_t first = *value;
	4611	+
	4612	+ // 1, t (true), T* (True), y* (yes), Y* (YES)
	4613	+ return (first == '1' \|\| first == 't' \|\| first == 'T' \|\| first == 'y' \|\| first == 'Y');
	4614	+ }
	4615	+
	4616	+#ifdef PUGIXML_HAS_LONG_LONG
	4617	+ PUGI__FN long long get_value_llong(const char_t* value)
	4618	+ {
	4619	+ return string_to_integer<unsigned long long>(value, static_cast<unsigned long long>(LLONG_MIN), LLONG_MAX);
	4620	+ }
	4621	+
	4622	+ PUGI__FN unsigned long long get_value_ullong(const char_t* value)
	4623	+ {
	4624	+ return string_to_integer<unsigned long long>(value, 0, ULLONG_MAX);
	4625	+ }
	4626	+#endif
	4627	+
	4628	+ template <typename U> PUGI__FN PUGI__UNSIGNED_OVERFLOW char_t* integer_to_string(char_t* begin, char_t* end, U value, bool negative)
	4629	+ {
	4630	+ char_t* result = end - 1;
	4631	+ U rest = negative ? 0 - value : value;
	4632	+
	4633	+ do
	4634	+ {
	4635	+ *result-- = static_cast<char_t>('0' + (rest % 10));
	4636	+ rest /= 10;
	4637	+ }
	4638	+ while (rest);
	4639	+
	4640	+ assert(result >= begin);
	4641	+ (void)begin;
	4642	+
	4643	+ *result = '-';
	4644	+
	4645	+ return result + !negative;
	4646	+ }
	4647	+
	4648	+ // set value with conversion functions
	4649	+ template <typename String, typename Header>
	4650	+ PUGI__FN bool set_value_ascii(String& dest, Header& header, uintptr_t header_mask, char* buf)
	4651	+ {
	4652	+ #ifdef PUGIXML_WCHAR_MODE
	4653	+ char_t wbuf[128];
	4654	+ assert(strlen(buf) < sizeof(wbuf) / sizeof(wbuf[0]));
	4655	+
	4656	+ size_t offset = 0;
	4657	+ for (; buf[offset]; ++offset) wbuf[offset] = buf[offset];
	4658	+
	4659	+ return strcpy_insitu(dest, header, header_mask, wbuf, offset);
	4660	+ #else
	4661	+ return strcpy_insitu(dest, header, header_mask, buf, strlen(buf));
	4662	+ #endif
	4663	+ }
	4664	+
	4665	+ template <typename U, typename String, typename Header>
	4666	+ PUGI__FN bool set_value_integer(String& dest, Header& header, uintptr_t header_mask, U value, bool negative)
	4667	+ {
	4668	+ char_t buf[64];
	4669	+ char_t* end = buf + sizeof(buf) / sizeof(buf[0]);
	4670	+ char_t* begin = integer_to_string(buf, end, value, negative);
	4671	+
	4672	+ return strcpy_insitu(dest, header, header_mask, begin, end - begin);
	4673	+ }
	4674	+
	4675	+ template <typename String, typename Header>
	4676	+ PUGI__FN bool set_value_convert(String& dest, Header& header, uintptr_t header_mask, float value, int precision)
	4677	+ {
	4678	+ char buf[128];
	4679	+ PUGI__SNPRINTF(buf, "%.*g", precision, double(value));
	4680	+
	4681	+ return set_value_ascii(dest, header, header_mask, buf);
	4682	+ }
	4683	+
	4684	+ template <typename String, typename Header>
	4685	+ PUGI__FN bool set_value_convert(String& dest, Header& header, uintptr_t header_mask, double value, int precision)
	4686	+ {
	4687	+ char buf[128];
	4688	+ PUGI__SNPRINTF(buf, "%.*g", precision, value);
	4689	+
	4690	+ return set_value_ascii(dest, header, header_mask, buf);
	4691	+ }
	4692	+
	4693	+ template <typename String, typename Header>
	4694	+ PUGI__FN bool set_value_bool(String& dest, Header& header, uintptr_t header_mask, bool value)
	4695	+ {
	4696	+ return strcpy_insitu(dest, header, header_mask, value ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false"), value ? 4 : 5);
	4697	+ }
	4698	+
	4699	+ PUGI__FN xml_parse_result load_buffer_impl(xml_document_struct* doc, xml_node_struct* root, void* contents, size_t size, unsigned int options, xml_encoding encoding, bool is_mutable, bool own, char_t** out_buffer)
	4700	+ {
	4701	+ // check input buffer
	4702	+ if (!contents && size) return make_parse_result(status_io_error);
	4703	+
	4704	+ // get actual encoding
	4705	+ xml_encoding buffer_encoding = impl::get_buffer_encoding(encoding, contents, size);
	4706	+
	4707	+ // get private buffer
	4708	+ char_t* buffer = 0;
	4709	+ size_t length = 0;
	4710	+
	4711	+ // coverity[var_deref_model]
	4712	+ if (!impl::convert_buffer(buffer, length, buffer_encoding, contents, size, is_mutable)) return impl::make_parse_result(status_out_of_memory);
	4713	+
	4714	+ // delete original buffer if we performed a conversion
	4715	+ if (own && buffer != contents && contents) impl::xml_memory::deallocate(contents);
	4716	+
	4717	+ // grab onto buffer if it's our buffer, user is responsible for deallocating contents himself
	4718	+ if (own \|\| buffer != contents) *out_buffer = buffer;
	4719	+
	4720	+ // store buffer for offset_debug
	4721	+ doc->buffer = buffer;
	4722	+
	4723	+ // parse
	4724	+ xml_parse_result res = impl::xml_parser::parse(buffer, length, doc, root, options);
	4725	+
	4726	+ // remember encoding
	4727	+ res.encoding = buffer_encoding;
	4728	+
	4729	+ return res;
	4730	+ }
	4731	+
	4732	+ // we need to get length of entire file to load it in memory; the only (relatively) sane way to do it is via seek/tell trick
	4733	+ PUGI__FN xml_parse_status get_file_size(FILE* file, size_t& out_result)
	4734	+ {
	4735	+ #if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE)
	4736	+ // there are 64-bit versions of fseek/ftell, let's use them
	4737	+ typedef __int64 length_type;
	4738	+
	4739	+ _fseeki64(file, 0, SEEK_END);
	4740	+ length_type length = _ftelli64(file);
	4741	+ _fseeki64(file, 0, SEEK_SET);
	4742	+ #elif defined(__MINGW32__) && !defined(__NO_MINGW_LFS) && (!defined(__STRICT_ANSI__) \|\| defined(__MINGW64_VERSION_MAJOR))
	4743	+ // there are 64-bit versions of fseek/ftell, let's use them
	4744	+ typedef off64_t length_type;
	4745	+
	4746	+ fseeko64(file, 0, SEEK_END);
	4747	+ length_type length = ftello64(file);
	4748	+ fseeko64(file, 0, SEEK_SET);
	4749	+ #else
	4750	+ // if this is a 32-bit OS, long is enough; if this is a unix system, long is 64-bit, which is enough; otherwise we can't do anything anyway.
	4751	+ typedef long length_type;
	4752	+
	4753	+ fseek(file, 0, SEEK_END);
	4754	+ length_type length = ftell(file);
	4755	+ fseek(file, 0, SEEK_SET);
	4756	+ #endif
	4757	+
	4758	+ // check for I/O errors
	4759	+ if (length < 0) return status_io_error;
	4760	+
	4761	+ // check for overflow
	4762	+ size_t result = static_cast<size_t>(length);
	4763	+
	4764	+ if (static_cast<length_type>(result) != length) return status_out_of_memory;
	4765	+
	4766	+ // finalize
	4767	+ out_result = result;
	4768	+
	4769	+ return status_ok;
	4770	+ }
	4771	+
	4772	+ // This function assumes that buffer has extra sizeof(char_t) writable bytes after size
	4773	+ PUGI__FN size_t zero_terminate_buffer(void* buffer, size_t size, xml_encoding encoding)
	4774	+ {
	4775	+ // We only need to zero-terminate if encoding conversion does not do it for us
	4776	+ #ifdef PUGIXML_WCHAR_MODE
	4777	+ xml_encoding wchar_encoding = get_wchar_encoding();
	4778	+
	4779	+ if (encoding == wchar_encoding \|\| need_endian_swap_utf(encoding, wchar_encoding))
	4780	+ {
	4781	+ size_t length = size / sizeof(char_t);
	4782	+
	4783	+ static_cast<char_t*>(buffer)[length] = 0;
	4784	+ return (length + 1) * sizeof(char_t);
	4785	+ }
	4786	+ #else
	4787	+ if (encoding == encoding_utf8)
	4788	+ {
	4789	+ static_cast<char*>(buffer)[size] = 0;
	4790	+ return size + 1;
	4791	+ }
	4792	+ #endif
	4793	+
	4794	+ return size;
	4795	+ }
	4796	+
	4797	+ PUGI__FN xml_parse_result load_file_impl(xml_document_struct* doc, FILE* file, unsigned int options, xml_encoding encoding, char_t** out_buffer)
	4798	+ {
	4799	+ if (!file) return make_parse_result(status_file_not_found);
	4800	+
	4801	+ // get file size (can result in I/O errors)
	4802	+ size_t size = 0;
	4803	+ xml_parse_status size_status = get_file_size(file, size);
	4804	+ if (size_status != status_ok) return make_parse_result(size_status);
	4805	+
	4806	+ size_t max_suffix_size = sizeof(char_t);
	4807	+
	4808	+ // allocate buffer for the whole file
	4809	+ char* contents = static_cast<char*>(xml_memory::allocate(size + max_suffix_size));
	4810	+ if (!contents) return make_parse_result(status_out_of_memory);
	4811	+
	4812	+ // read file in memory
	4813	+ size_t read_size = fread(contents, 1, size, file);
	4814	+
	4815	+ if (read_size != size)
	4816	+ {
	4817	+ xml_memory::deallocate(contents);
	4818	+ return make_parse_result(status_io_error);
	4819	+ }
	4820	+
	4821	+ xml_encoding real_encoding = get_buffer_encoding(encoding, contents, size);
	4822	+
	4823	+ return load_buffer_impl(doc, doc, contents, zero_terminate_buffer(contents, size, real_encoding), options, real_encoding, true, true, out_buffer);
	4824	+ }
	4825	+
	4826	+ PUGI__FN void close_file(FILE* file)
	4827	+ {
	4828	+ fclose(file);
	4829	+ }
	4830	+
	4831	+#ifndef PUGIXML_NO_STL
	4832	+ template <typename T> struct xml_stream_chunk
	4833	+ {
	4834	+ static xml_stream_chunk* create()
	4835	+ {
	4836	+ void* memory = xml_memory::allocate(sizeof(xml_stream_chunk));
	4837	+ if (!memory) return 0;
	4838	+
	4839	+ return new (memory) xml_stream_chunk();
	4840	+ }
	4841	+
	4842	+ static void destroy(xml_stream_chunk* chunk)
	4843	+ {
	4844	+ // free chunk chain
	4845	+ while (chunk)
	4846	+ {
	4847	+ xml_stream_chunk* next_ = chunk->next;
	4848	+
	4849	+ xml_memory::deallocate(chunk);
	4850	+
	4851	+ chunk = next_;
	4852	+ }
	4853	+ }
	4854	+
	4855	+ xml_stream_chunk(): next(0), size(0)
	4856	+ {
	4857	+ }
	4858	+
	4859	+ xml_stream_chunk* next;
	4860	+ size_t size;
	4861	+
	4862	+ T data[xml_memory_page_size / sizeof(T)];
	4863	+ };
	4864	+
	4865	+ template <typename T> PUGI__FN xml_parse_status load_stream_data_noseek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
	4866	+ {
	4867	+ auto_deleter<xml_stream_chunk<T> > chunks(0, xml_stream_chunk<T>::destroy);
	4868	+
	4869	+ // read file to a chunk list
	4870	+ size_t total = 0;
	4871	+ xml_stream_chunk<T>* last = 0;
	4872	+
	4873	+ while (!stream.eof())
	4874	+ {
	4875	+ // allocate new chunk
	4876	+ xml_stream_chunk<T>* chunk = xml_stream_chunk<T>::create();
	4877	+ if (!chunk) return status_out_of_memory;
	4878	+
	4879	+ // append chunk to list
	4880	+ if (last) last = last->next = chunk;
	4881	+ else chunks.data = last = chunk;
	4882	+
	4883	+ // read data to chunk
	4884	+ stream.read(chunk->data, static_cast<std::streamsize>(sizeof(chunk->data) / sizeof(T)));
	4885	+ chunk->size = static_cast<size_t>(stream.gcount()) * sizeof(T);
	4886	+
	4887	+ // read may set failbit \| eofbit in case gcount() is less than read length, so check for other I/O errors
	4888	+ if (stream.bad() \|\| (!stream.eof() && stream.fail())) return status_io_error;
	4889	+
	4890	+ // guard against huge files (chunk size is small enough to make this overflow check work)
	4891	+ if (total + chunk->size < total) return status_out_of_memory;
	4892	+ total += chunk->size;
	4893	+ }
	4894	+
	4895	+ size_t max_suffix_size = sizeof(char_t);
	4896	+
	4897	+ // copy chunk list to a contiguous buffer
	4898	+ char* buffer = static_cast<char*>(xml_memory::allocate(total + max_suffix_size));
	4899	+ if (!buffer) return status_out_of_memory;
	4900	+
	4901	+ char* write = buffer;
	4902	+
	4903	+ for (xml_stream_chunk<T>* chunk = chunks.data; chunk; chunk = chunk->next)
	4904	+ {
	4905	+ assert(write + chunk->size <= buffer + total);
	4906	+ memcpy(write, chunk->data, chunk->size);
	4907	+ write += chunk->size;
	4908	+ }
	4909	+
	4910	+ assert(write == buffer + total);
	4911	+
	4912	+ // return buffer
	4913	+ *out_buffer = buffer;
	4914	+ *out_size = total;
	4915	+
	4916	+ return status_ok;
	4917	+ }
	4918	+
	4919	+ template <typename T> PUGI__FN xml_parse_status load_stream_data_seek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
	4920	+ {
	4921	+ // get length of remaining data in stream
	4922	+ typename std::basic_istream<T>::pos_type pos = stream.tellg();
	4923	+ stream.seekg(0, std::ios::end);
	4924	+ std::streamoff length = stream.tellg() - pos;
	4925	+ stream.seekg(pos);
	4926	+
	4927	+ if (stream.fail() \|\| pos < 0) return status_io_error;
	4928	+
	4929	+ // guard against huge files
	4930	+ size_t read_length = static_cast<size_t>(length);
	4931	+
	4932	+ if (static_cast<std::streamsize>(read_length) != length \|\| length < 0) return status_out_of_memory;
	4933	+
	4934	+ size_t max_suffix_size = sizeof(char_t);
	4935	+
	4936	+ // read stream data into memory (guard against stream exceptions with buffer holder)
	4937	+ auto_deleter<void> buffer(xml_memory::allocate(read_length * sizeof(T) + max_suffix_size), xml_memory::deallocate);
	4938	+ if (!buffer.data) return status_out_of_memory;
	4939	+
	4940	+ stream.read(static_cast<T*>(buffer.data), static_cast<std::streamsize>(read_length));
	4941	+
	4942	+ // 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
	4943	+ if (stream.bad() \|\| (!stream.eof() && stream.fail())) return status_io_error;
	4944	+
	4945	+ // return buffer
	4946	+ size_t actual_length = static_cast<size_t>(stream.gcount());
	4947	+ assert(actual_length <= read_length);
	4948	+
	4949	+ *out_buffer = buffer.release();
	4950	+ out_size = actual_length sizeof(T);
	4951	+
	4952	+ return status_ok;
	4953	+ }
	4954	+
	4955	+ template <typename T> PUGI__FN xml_parse_result load_stream_impl(xml_document_struct* doc, std::basic_istream<T>& stream, unsigned int options, xml_encoding encoding, char_t** out_buffer)
	4956	+ {
	4957	+ void* buffer = 0;
	4958	+ size_t size = 0;
	4959	+ xml_parse_status status = status_ok;
	4960	+
	4961	+ // if stream has an error bit set, bail out (otherwise tellg() can fail and we'll clear error bits)
	4962	+ if (stream.fail()) return make_parse_result(status_io_error);
	4963	+
	4964	+ // load stream to memory (using seek-based implementation if possible, since it's faster and takes less memory)
	4965	+ if (stream.tellg() < 0)
	4966	+ {
	4967	+ stream.clear(); // clear error flags that could be set by a failing tellg
	4968	+ status = load_stream_data_noseek(stream, &buffer, &size);
	4969	+ }
	4970	+ else
	4971	+ status = load_stream_data_seek(stream, &buffer, &size);
	4972	+
	4973	+ if (status != status_ok) return make_parse_result(status);
	4974	+
	4975	+ xml_encoding real_encoding = get_buffer_encoding(encoding, buffer, size);
	4976	+
	4977	+ return load_buffer_impl(doc, doc, buffer, zero_terminate_buffer(buffer, size, real_encoding), options, real_encoding, true, true, out_buffer);
	4978	+ }
	4979	+#endif
	4980	+
	4981	+#if defined(PUGI__MSVC_CRT_VERSION) \|\| defined(__BORLANDC__) \|\| (defined(__MINGW32__) && (!defined(__STRICT_ANSI__) \|\| defined(__MINGW64_VERSION_MAJOR)))
	4982	+ PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
	4983	+ {
	4984	+#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400
	4985	+ FILE* file = 0;
	4986	+ return _wfopen_s(&file, path, mode) == 0 ? file : 0;
	4987	+#else
	4988	+ return _wfopen(path, mode);
	4989	+#endif
	4990	+ }
	4991	+#else
	4992	+ PUGI__FN char* convert_path_heap(const wchar_t* str)
	4993	+ {
	4994	+ assert(str);
	4995	+
	4996	+ // first pass: get length in utf8 characters
	4997	+ size_t length = strlength_wide(str);
	4998	+ size_t size = as_utf8_begin(str, length);
	4999	+
	5000	+ // allocate resulting string
	5001	+ char* result = static_cast<char*>(xml_memory::allocate(size + 1));
	5002	+ if (!result) return 0;
	5003	+
	5004	+ // second pass: convert to utf8
	5005	+ as_utf8_end(result, size, str, length);
	5006	+
	5007	+ // zero-terminate
	5008	+ result[size] = 0;
	5009	+
	5010	+ return result;
	5011	+ }
	5012	+
	5013	+ PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
	5014	+ {
	5015	+ // there is no standard function to open wide paths, so our best bet is to try utf8 path
	5016	+ char* path_utf8 = convert_path_heap(path);
	5017	+ if (!path_utf8) return 0;
	5018	+
	5019	+ // convert mode to ASCII (we mirror _wfopen interface)
	5020	+ char mode_ascii[4] = {0};
	5021	+ for (size_t i = 0; mode[i]; ++i) mode_ascii[i] = static_cast<char>(mode[i]);
	5022	+
	5023	+ // try to open the utf8 path
	5024	+ FILE* result = fopen(path_utf8, mode_ascii);
	5025	+
	5026	+ // free dummy buffer
	5027	+ xml_memory::deallocate(path_utf8);
	5028	+
	5029	+ return result;
	5030	+ }
	5031	+#endif
	5032	+
	5033	+ PUGI__FN FILE* open_file(const char* path, const char* mode)
	5034	+ {
	5035	+#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400
	5036	+ FILE* file = 0;
	5037	+ return fopen_s(&file, path, mode) == 0 ? file : 0;
	5038	+#else
	5039	+ return fopen(path, mode);
	5040	+#endif
	5041	+ }
	5042	+
	5043	+ PUGI__FN bool save_file_impl(const xml_document& doc, FILE* file, const char_t* indent, unsigned int flags, xml_encoding encoding)
	5044	+ {
	5045	+ if (!file) return false;
	5046	+
	5047	+ xml_writer_file writer(file);
	5048	+ doc.save(writer, indent, flags, encoding);
	5049	+
	5050	+ return ferror(file) == 0;
	5051	+ }
	5052	+
	5053	+ struct name_null_sentry
	5054	+ {
	5055	+ xml_node_struct* node;
	5056	+ char_t* name;
	5057	+
	5058	+ name_null_sentry(xml_node_struct* node_): node(node_), name(node_->name)
	5059	+ {
	5060	+ node->name = 0;
	5061	+ }
	5062	+
	5063	+ ~name_null_sentry()
	5064	+ {
	5065	+ node->name = name;
	5066	+ }
	5067	+ };
	5068	+PUGI__NS_END
	5069	+
	5070	+namespace pugi
	5071	+{
	5072	+ PUGI__FN xml_writer_file::xml_writer_file(void* file_): file(file_)
	5073	+ {
	5074	+ }
	5075	+
	5076	+ PUGI__FN void xml_writer_file::write(const void* data, size_t size)
	5077	+ {
	5078	+ size_t result = fwrite(data, 1, size, static_cast<FILE*>(file));
	5079	+ (void)!result; // unfortunately we can't do proper error handling here
	5080	+ }
	5081	+
	5082	+#ifndef PUGIXML_NO_STL
	5083	+ PUGI__FN xml_writer_stream::xml_writer_stream(std::basic_ostream<char, std::char_traits<char> >& stream): narrow_stream(&stream), wide_stream(0)
	5084	+ {
	5085	+ }
	5086	+
	5087	+ PUGI__FN xml_writer_stream::xml_writer_stream(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream): narrow_stream(0), wide_stream(&stream)
	5088	+ {
	5089	+ }
	5090	+
	5091	+ PUGI__FN void xml_writer_stream::write(const void* data, size_t size)
	5092	+ {
	5093	+ if (narrow_stream)
	5094	+ {
	5095	+ assert(!wide_stream);
	5096	+ narrow_stream->write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
	5097	+ }
	5098	+ else
	5099	+ {
	5100	+ assert(wide_stream);
	5101	+ assert(size % sizeof(wchar_t) == 0);
	5102	+
	5103	+ wide_stream->write(reinterpret_cast<const wchar_t*>(data), static_cast<std::streamsize>(size / sizeof(wchar_t)));
	5104	+ }
	5105	+ }
	5106	+#endif
	5107	+
	5108	+ PUGI__FN xml_tree_walker::xml_tree_walker(): _depth(0)
	5109	+ {
	5110	+ }
	5111	+
	5112	+ PUGI__FN xml_tree_walker::~xml_tree_walker()
	5113	+ {
	5114	+ }
	5115	+
	5116	+ PUGI__FN int xml_tree_walker::depth() const
	5117	+ {
	5118	+ return _depth;
	5119	+ }
	5120	+
	5121	+ PUGI__FN bool xml_tree_walker::begin(xml_node&)
	5122	+ {
	5123	+ return true;
	5124	+ }
	5125	+
	5126	+ PUGI__FN bool xml_tree_walker::end(xml_node&)
	5127	+ {
	5128	+ return true;
	5129	+ }
	5130	+
	5131	+ PUGI__FN xml_attribute::xml_attribute(): _attr(0)
	5132	+ {
	5133	+ }
	5134	+
	5135	+ PUGI__FN xml_attribute::xml_attribute(xml_attribute_struct* attr): _attr(attr)
	5136	+ {
	5137	+ }
	5138	+
	5139	+ PUGI__FN static void unspecified_bool_xml_attribute(xml_attribute***)
	5140	+ {
	5141	+ }
	5142	+
	5143	+ PUGI__FN xml_attribute::operator xml_attribute::unspecified_bool_type() const
	5144	+ {
	5145	+ return _attr ? unspecified_bool_xml_attribute : 0;
	5146	+ }
	5147	+
	5148	+ PUGI__FN bool xml_attribute::operator!() const
	5149	+ {
	5150	+ return !_attr;
	5151	+ }
	5152	+
	5153	+ PUGI__FN bool xml_attribute::operator==(const xml_attribute& r) const
	5154	+ {
	5155	+ return (_attr == r._attr);
	5156	+ }
	5157	+
	5158	+ PUGI__FN bool xml_attribute::operator!=(const xml_attribute& r) const
	5159	+ {
	5160	+ return (_attr != r._attr);
	5161	+ }
	5162	+
	5163	+ PUGI__FN bool xml_attribute::operator<(const xml_attribute& r) const
	5164	+ {
	5165	+ return (_attr < r._attr);
	5166	+ }
	5167	+
	5168	+ PUGI__FN bool xml_attribute::operator>(const xml_attribute& r) const
	5169	+ {
	5170	+ return (_attr > r._attr);
	5171	+ }
	5172	+
	5173	+ PUGI__FN bool xml_attribute::operator<=(const xml_attribute& r) const
	5174	+ {
	5175	+ return (_attr <= r._attr);
	5176	+ }
	5177	+
	5178	+ PUGI__FN bool xml_attribute::operator>=(const xml_attribute& r) const
	5179	+ {
	5180	+ return (_attr >= r._attr);
	5181	+ }
	5182	+
	5183	+ PUGI__FN xml_attribute xml_attribute::next_attribute() const
	5184	+ {
	5185	+ return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
	5186	+ }
	5187	+
	5188	+ PUGI__FN xml_attribute xml_attribute::previous_attribute() const
	5189	+ {
	5190	+ return _attr && _attr->prev_attribute_c->next_attribute ? xml_attribute(_attr->prev_attribute_c) : xml_attribute();
	5191	+ }
	5192	+
	5193	+ PUGI__FN const char_t* xml_attribute::as_string(const char_t* def) const
	5194	+ {
	5195	+ return (_attr && _attr->value) ? _attr->value + 0 : def;
	5196	+ }
	5197	+
	5198	+ PUGI__FN int xml_attribute::as_int(int def) const
	5199	+ {
	5200	+ return (_attr && _attr->value) ? impl::get_value_int(_attr->value) : def;
	5201	+ }
	5202	+
	5203	+ PUGI__FN unsigned int xml_attribute::as_uint(unsigned int def) const
	5204	+ {
	5205	+ return (_attr && _attr->value) ? impl::get_value_uint(_attr->value) : def;
	5206	+ }
	5207	+
	5208	+ PUGI__FN double xml_attribute::as_double(double def) const
	5209	+ {
	5210	+ return (_attr && _attr->value) ? impl::get_value_double(_attr->value) : def;
	5211	+ }
	5212	+
	5213	+ PUGI__FN float xml_attribute::as_float(float def) const
	5214	+ {
	5215	+ return (_attr && _attr->value) ? impl::get_value_float(_attr->value) : def;
	5216	+ }
	5217	+
	5218	+ PUGI__FN bool xml_attribute::as_bool(bool def) const
	5219	+ {
	5220	+ return (_attr && _attr->value) ? impl::get_value_bool(_attr->value) : def;
	5221	+ }
	5222	+
	5223	+#ifdef PUGIXML_HAS_LONG_LONG
	5224	+ PUGI__FN long long xml_attribute::as_llong(long long def) const
	5225	+ {
	5226	+ return (_attr && _attr->value) ? impl::get_value_llong(_attr->value) : def;
	5227	+ }
	5228	+
	5229	+ PUGI__FN unsigned long long xml_attribute::as_ullong(unsigned long long def) const
	5230	+ {
	5231	+ return (_attr && _attr->value) ? impl::get_value_ullong(_attr->value) : def;
	5232	+ }
	5233	+#endif
	5234	+
	5235	+ PUGI__FN bool xml_attribute::empty() const
	5236	+ {
	5237	+ return !_attr;
	5238	+ }
	5239	+
	5240	+ PUGI__FN const char_t* xml_attribute::name() const
	5241	+ {
	5242	+ return (_attr && _attr->name) ? _attr->name + 0 : PUGIXML_TEXT("");
	5243	+ }
	5244	+
	5245	+ PUGI__FN const char_t* xml_attribute::value() const
	5246	+ {
	5247	+ return (_attr && _attr->value) ? _attr->value + 0 : PUGIXML_TEXT("");
	5248	+ }
	5249	+
	5250	+ PUGI__FN size_t xml_attribute::hash_value() const
	5251	+ {
	5252	+ return static_cast<size_t>(reinterpret_cast<uintptr_t>(_attr) / sizeof(xml_attribute_struct));
	5253	+ }
	5254	+
	5255	+ PUGI__FN xml_attribute_struct* xml_attribute::internal_object() const
	5256	+ {
	5257	+ return _attr;
	5258	+ }
	5259	+
	5260	+ PUGI__FN xml_attribute& xml_attribute::operator=(const char_t* rhs)
	5261	+ {
	5262	+ set_value(rhs);
	5263	+ return *this;
	5264	+ }
	5265	+
	5266	+ PUGI__FN xml_attribute& xml_attribute::operator=(int rhs)
	5267	+ {
	5268	+ set_value(rhs);
	5269	+ return *this;
	5270	+ }
	5271	+
	5272	+ PUGI__FN xml_attribute& xml_attribute::operator=(unsigned int rhs)
	5273	+ {
	5274	+ set_value(rhs);
	5275	+ return *this;
	5276	+ }
	5277	+
	5278	+ PUGI__FN xml_attribute& xml_attribute::operator=(long rhs)
	5279	+ {
	5280	+ set_value(rhs);
	5281	+ return *this;
	5282	+ }
	5283	+
	5284	+ PUGI__FN xml_attribute& xml_attribute::operator=(unsigned long rhs)
	5285	+ {
	5286	+ set_value(rhs);
	5287	+ return *this;
	5288	+ }
	5289	+
	5290	+ PUGI__FN xml_attribute& xml_attribute::operator=(double rhs)
	5291	+ {
	5292	+ set_value(rhs);
	5293	+ return *this;
	5294	+ }
	5295	+
	5296	+ PUGI__FN xml_attribute& xml_attribute::operator=(float rhs)
	5297	+ {
	5298	+ set_value(rhs);
	5299	+ return *this;
	5300	+ }
	5301	+
	5302	+ PUGI__FN xml_attribute& xml_attribute::operator=(bool rhs)
	5303	+ {
	5304	+ set_value(rhs);
	5305	+ return *this;
	5306	+ }
	5307	+
	5308	+#ifdef PUGIXML_HAS_LONG_LONG
	5309	+ PUGI__FN xml_attribute& xml_attribute::operator=(long long rhs)
	5310	+ {
	5311	+ set_value(rhs);
	5312	+ return *this;
	5313	+ }
	5314	+
	5315	+ PUGI__FN xml_attribute& xml_attribute::operator=(unsigned long long rhs)
	5316	+ {
	5317	+ set_value(rhs);
	5318	+ return *this;
	5319	+ }
	5320	+#endif
	5321	+
	5322	+ PUGI__FN bool xml_attribute::set_name(const char_t* rhs)
	5323	+ {
	5324	+ if (!_attr) return false;
	5325	+
	5326	+ return impl::strcpy_insitu(_attr->name, _attr->header, impl::xml_memory_page_name_allocated_mask, rhs, impl::strlength(rhs));
	5327	+ }
	5328	+
	5329	+ PUGI__FN bool xml_attribute::set_value(const char_t* rhs)
	5330	+ {
	5331	+ if (!_attr) return false;
	5332	+
	5333	+ return impl::strcpy_insitu(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, impl::strlength(rhs));
	5334	+ }
	5335	+
	5336	+ PUGI__FN bool xml_attribute::set_value(int rhs)
	5337	+ {
	5338	+ if (!_attr) return false;
	5339	+
	5340	+ return impl::set_value_integer<unsigned int>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0);
	5341	+ }
	5342	+
	5343	+ PUGI__FN bool xml_attribute::set_value(unsigned int rhs)
	5344	+ {
	5345	+ if (!_attr) return false;
	5346	+
	5347	+ return impl::set_value_integer<unsigned int>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, false);
	5348	+ }
	5349	+
	5350	+ PUGI__FN bool xml_attribute::set_value(long rhs)
	5351	+ {
	5352	+ if (!_attr) return false;
	5353	+
	5354	+ return impl::set_value_integer<unsigned long>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0);
	5355	+ }
	5356	+
	5357	+ PUGI__FN bool xml_attribute::set_value(unsigned long rhs)
	5358	+ {
	5359	+ if (!_attr) return false;
	5360	+
	5361	+ return impl::set_value_integer<unsigned long>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, false);
	5362	+ }
	5363	+
	5364	+ PUGI__FN bool xml_attribute::set_value(double rhs)
	5365	+ {
	5366	+ if (!_attr) return false;
	5367	+
	5368	+ return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, default_double_precision);
	5369	+ }
	5370	+
	5371	+ PUGI__FN bool xml_attribute::set_value(double rhs, int precision)
	5372	+ {
	5373	+ if (!_attr) return false;
	5374	+
	5375	+ return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, precision);
	5376	+ }
	5377	+
	5378	+ PUGI__FN bool xml_attribute::set_value(float rhs)
	5379	+ {
	5380	+ if (!_attr) return false;
	5381	+
	5382	+ return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, default_float_precision);
	5383	+ }
	5384	+
	5385	+ PUGI__FN bool xml_attribute::set_value(float rhs, int precision)
	5386	+ {
	5387	+ if (!_attr) return false;
	5388	+
	5389	+ return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, precision);
	5390	+ }
	5391	+
	5392	+ PUGI__FN bool xml_attribute::set_value(bool rhs)
	5393	+ {
	5394	+ if (!_attr) return false;
	5395	+
	5396	+ return impl::set_value_bool(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
	5397	+ }
	5398	+
	5399	+#ifdef PUGIXML_HAS_LONG_LONG
	5400	+ PUGI__FN bool xml_attribute::set_value(long long rhs)
	5401	+ {
	5402	+ if (!_attr) return false;
	5403	+
	5404	+ return impl::set_value_integer<unsigned long long>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0);
	5405	+ }
	5406	+
	5407	+ PUGI__FN bool xml_attribute::set_value(unsigned long long rhs)
	5408	+ {
	5409	+ if (!_attr) return false;
	5410	+
	5411	+ return impl::set_value_integer<unsigned long long>(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs, false);
	5412	+ }
	5413	+#endif
	5414	+
	5415	+#ifdef __BORLANDC__
	5416	+ PUGI__FN bool operator&&(const xml_attribute& lhs, bool rhs)
	5417	+ {
	5418	+ return (bool)lhs && rhs;
	5419	+ }
	5420	+
	5421	+ PUGI__FN bool operator\|\|(const xml_attribute& lhs, bool rhs)
	5422	+ {
	5423	+ return (bool)lhs \|\| rhs;
	5424	+ }
	5425	+#endif
	5426	+
	5427	+ PUGI__FN xml_node::xml_node(): _root(0)
	5428	+ {
	5429	+ }
	5430	+
	5431	+ PUGI__FN xml_node::xml_node(xml_node_struct* p): _root(p)
	5432	+ {
	5433	+ }
	5434	+
	5435	+ PUGI__FN static void unspecified_bool_xml_node(xml_node***)
	5436	+ {
	5437	+ }
	5438	+
	5439	+ PUGI__FN xml_node::operator xml_node::unspecified_bool_type() const
	5440	+ {
	5441	+ return _root ? unspecified_bool_xml_node : 0;
	5442	+ }
	5443	+
	5444	+ PUGI__FN bool xml_node::operator!() const
	5445	+ {
	5446	+ return !_root;
	5447	+ }
	5448	+
	5449	+ PUGI__FN xml_node::iterator xml_node::begin() const
	5450	+ {
	5451	+ return iterator(_root ? _root->first_child + 0 : 0, _root);
	5452	+ }
	5453	+
	5454	+ PUGI__FN xml_node::iterator xml_node::end() const
	5455	+ {
	5456	+ return iterator(0, _root);
	5457	+ }
	5458	+
	5459	+ PUGI__FN xml_node::attribute_iterator xml_node::attributes_begin() const
	5460	+ {
	5461	+ return attribute_iterator(_root ? _root->first_attribute + 0 : 0, _root);
	5462	+ }
	5463	+
	5464	+ PUGI__FN xml_node::attribute_iterator xml_node::attributes_end() const
	5465	+ {
	5466	+ return attribute_iterator(0, _root);
	5467	+ }
	5468	+
	5469	+ PUGI__FN xml_object_range<xml_node_iterator> xml_node::children() const
	5470	+ {
	5471	+ return xml_object_range<xml_node_iterator>(begin(), end());
	5472	+ }
	5473	+
	5474	+ PUGI__FN xml_object_range<xml_named_node_iterator> xml_node::children(const char_t* name_) const
	5475	+ {
	5476	+ return xml_object_range<xml_named_node_iterator>(xml_named_node_iterator(child(name_)._root, _root, name_), xml_named_node_iterator(0, _root, name_));
	5477	+ }
	5478	+
	5479	+ PUGI__FN xml_object_range<xml_attribute_iterator> xml_node::attributes() const
	5480	+ {
	5481	+ return xml_object_range<xml_attribute_iterator>(attributes_begin(), attributes_end());
	5482	+ }
	5483	+
	5484	+ PUGI__FN bool xml_node::operator==(const xml_node& r) const
	5485	+ {
	5486	+ return (_root == r._root);
	5487	+ }
	5488	+
	5489	+ PUGI__FN bool xml_node::operator!=(const xml_node& r) const
	5490	+ {
	5491	+ return (_root != r._root);
	5492	+ }
	5493	+
	5494	+ PUGI__FN bool xml_node::operator<(const xml_node& r) const
	5495	+ {
	5496	+ return (_root < r._root);
	5497	+ }
	5498	+
	5499	+ PUGI__FN bool xml_node::operator>(const xml_node& r) const
	5500	+ {
	5501	+ return (_root > r._root);
	5502	+ }
	5503	+
	5504	+ PUGI__FN bool xml_node::operator<=(const xml_node& r) const
	5505	+ {
	5506	+ return (_root <= r._root);
	5507	+ }
	5508	+
	5509	+ PUGI__FN bool xml_node::operator>=(const xml_node& r) const
	5510	+ {
	5511	+ return (_root >= r._root);
	5512	+ }
	5513	+
	5514	+ PUGI__FN bool xml_node::empty() const
	5515	+ {
	5516	+ return !_root;
	5517	+ }
	5518	+
	5519	+ PUGI__FN const char_t* xml_node::name() const
	5520	+ {
	5521	+ return (_root && _root->name) ? _root->name + 0 : PUGIXML_TEXT("");
	5522	+ }
	5523	+
	5524	+ PUGI__FN xml_node_type xml_node::type() const
	5525	+ {
	5526	+ return _root ? PUGI__NODETYPE(_root) : node_null;
	5527	+ }
	5528	+
	5529	+ PUGI__FN const char_t* xml_node::value() const
	5530	+ {
	5531	+ return (_root && _root->value) ? _root->value + 0 : PUGIXML_TEXT("");
	5532	+ }
	5533	+
	5534	+ PUGI__FN xml_node xml_node::child(const char_t* name_) const
	5535	+ {
	5536	+ if (!_root) return xml_node();
	5537	+
	5538	+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
	5539	+ if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
	5540	+
	5541	+ return xml_node();
	5542	+ }
	5543	+
	5544	+ PUGI__FN xml_attribute xml_node::attribute(const char_t* name_) const
	5545	+ {
	5546	+ if (!_root) return xml_attribute();
	5547	+
	5548	+ for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
	5549	+ if (i->name && impl::strequal(name_, i->name))
	5550	+ return xml_attribute(i);
	5551	+
	5552	+ return xml_attribute();
	5553	+ }
	5554	+
	5555	+ PUGI__FN xml_node xml_node::next_sibling(const char_t* name_) const
	5556	+ {
	5557	+ if (!_root) return xml_node();
	5558	+
	5559	+ for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
	5560	+ if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
	5561	+
	5562	+ return xml_node();
	5563	+ }
	5564	+
	5565	+ PUGI__FN xml_node xml_node::next_sibling() const
	5566	+ {
	5567	+ return _root ? xml_node(_root->next_sibling) : xml_node();
	5568	+ }
	5569	+
	5570	+ PUGI__FN xml_node xml_node::previous_sibling(const char_t* name_) const
	5571	+ {
	5572	+ if (!_root) return xml_node();
	5573	+
	5574	+ for (xml_node_struct* i = _root->prev_sibling_c; i->next_sibling; i = i->prev_sibling_c)
	5575	+ if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
	5576	+
	5577	+ return xml_node();
	5578	+ }
	5579	+
	5580	+ PUGI__FN xml_attribute xml_node::attribute(const char_t* name_, xml_attribute& hint_) const
	5581	+ {
	5582	+ xml_attribute_struct* hint = hint_._attr;
	5583	+
	5584	+ // if hint is not an attribute of node, behavior is not defined
	5585	+ assert(!hint \|\| (_root && impl::is_attribute_of(hint, _root)));
	5586	+
	5587	+ if (!_root) return xml_attribute();
	5588	+
	5589	+ // optimistically search from hint up until the end
	5590	+ for (xml_attribute_struct* i = hint; i; i = i->next_attribute)
	5591	+ if (i->name && impl::strequal(name_, i->name))
	5592	+ {
	5593	+ // update hint to maximize efficiency of searching for consecutive attributes
	5594	+ hint_._attr = i->next_attribute;
	5595	+
	5596	+ return xml_attribute(i);
	5597	+ }
	5598	+
	5599	+ // wrap around and search from the first attribute until the hint
	5600	+ // 'j' null pointer check is technically redundant, but it prevents a crash in case the assertion above fails
	5601	+ for (xml_attribute_struct* j = _root->first_attribute; j && j != hint; j = j->next_attribute)
	5602	+ if (j->name && impl::strequal(name_, j->name))
	5603	+ {
	5604	+ // update hint to maximize efficiency of searching for consecutive attributes
	5605	+ hint_._attr = j->next_attribute;
	5606	+
	5607	+ return xml_attribute(j);
	5608	+ }
	5609	+
	5610	+ return xml_attribute();
	5611	+ }
	5612	+
	5613	+ PUGI__FN xml_node xml_node::previous_sibling() const
	5614	+ {
	5615	+ if (!_root) return xml_node();
	5616	+
	5617	+ if (_root->prev_sibling_c->next_sibling) return xml_node(_root->prev_sibling_c);
	5618	+ else return xml_node();
	5619	+ }
	5620	+
	5621	+ PUGI__FN xml_node xml_node::parent() const
	5622	+ {
	5623	+ return _root ? xml_node(_root->parent) : xml_node();
	5624	+ }
	5625	+
	5626	+ PUGI__FN xml_node xml_node::root() const
	5627	+ {
	5628	+ return _root ? xml_node(&impl::get_document(_root)) : xml_node();
	5629	+ }
	5630	+
	5631	+ PUGI__FN xml_text xml_node::text() const
	5632	+ {
	5633	+ return xml_text(_root);
	5634	+ }
	5635	+
	5636	+ PUGI__FN const char_t* xml_node::child_value() const
	5637	+ {
	5638	+ if (!_root) return PUGIXML_TEXT("");
	5639	+
	5640	+ // element nodes can have value if parse_embed_pcdata was used
	5641	+ if (PUGI__NODETYPE(_root) == node_element && _root->value)
	5642	+ return _root->value;
	5643	+
	5644	+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
	5645	+ if (impl::is_text_node(i) && i->value)
	5646	+ return i->value;
	5647	+
	5648	+ return PUGIXML_TEXT("");
	5649	+ }
	5650	+
	5651	+ PUGI__FN const char_t* xml_node::child_value(const char_t* name_) const
	5652	+ {
	5653	+ return child(name_).child_value();
	5654	+ }
	5655	+
	5656	+ PUGI__FN xml_attribute xml_node::first_attribute() const
	5657	+ {
	5658	+ return _root ? xml_attribute(_root->first_attribute) : xml_attribute();
	5659	+ }
	5660	+
	5661	+ PUGI__FN xml_attribute xml_node::last_attribute() const
	5662	+ {
	5663	+ return _root && _root->first_attribute ? xml_attribute(_root->first_attribute->prev_attribute_c) : xml_attribute();
	5664	+ }
	5665	+
	5666	+ PUGI__FN xml_node xml_node::first_child() const
	5667	+ {
	5668	+ return _root ? xml_node(_root->first_child) : xml_node();
	5669	+ }
	5670	+
	5671	+ PUGI__FN xml_node xml_node::last_child() const
	5672	+ {
	5673	+ return _root && _root->first_child ? xml_node(_root->first_child->prev_sibling_c) : xml_node();
	5674	+ }
	5675	+
	5676	+ PUGI__FN bool xml_node::set_name(const char_t* rhs)
	5677	+ {
	5678	+ xml_node_type type_ = _root ? PUGI__NODETYPE(_root) : node_null;
	5679	+
	5680	+ if (type_ != node_element && type_ != node_pi && type_ != node_declaration)
	5681	+ return false;
	5682	+
	5683	+ return impl::strcpy_insitu(_root->name, _root->header, impl::xml_memory_page_name_allocated_mask, rhs, impl::strlength(rhs));
	5684	+ }
	5685	+
	5686	+ PUGI__FN bool xml_node::set_value(const char_t* rhs)
	5687	+ {
	5688	+ xml_node_type type_ = _root ? PUGI__NODETYPE(_root) : node_null;
	5689	+
	5690	+ if (type_ != node_pcdata && type_ != node_cdata && type_ != node_comment && type_ != node_pi && type_ != node_doctype)
	5691	+ return false;
	5692	+
	5693	+ return impl::strcpy_insitu(_root->value, _root->header, impl::xml_memory_page_value_allocated_mask, rhs, impl::strlength(rhs));
	5694	+ }
	5695	+
	5696	+ PUGI__FN xml_attribute xml_node::append_attribute(const char_t* name_)
	5697	+ {
	5698	+ if (!impl::allow_insert_attribute(type())) return xml_attribute();
	5699	+
	5700	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5701	+ if (!alloc.reserve()) return xml_attribute();
	5702	+
	5703	+ xml_attribute a(impl::allocate_attribute(alloc));
	5704	+ if (!a) return xml_attribute();
	5705	+
	5706	+ impl::append_attribute(a._attr, _root);
	5707	+
	5708	+ a.set_name(name_);
	5709	+
	5710	+ return a;
	5711	+ }
	5712	+
	5713	+ PUGI__FN xml_attribute xml_node::prepend_attribute(const char_t* name_)
	5714	+ {
	5715	+ if (!impl::allow_insert_attribute(type())) return xml_attribute();
	5716	+
	5717	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5718	+ if (!alloc.reserve()) return xml_attribute();
	5719	+
	5720	+ xml_attribute a(impl::allocate_attribute(alloc));
	5721	+ if (!a) return xml_attribute();
	5722	+
	5723	+ impl::prepend_attribute(a._attr, _root);
	5724	+
	5725	+ a.set_name(name_);
	5726	+
	5727	+ return a;
	5728	+ }
	5729	+
	5730	+ PUGI__FN xml_attribute xml_node::insert_attribute_after(const char_t* name_, const xml_attribute& attr)
	5731	+ {
	5732	+ if (!impl::allow_insert_attribute(type())) return xml_attribute();
	5733	+ if (!attr \|\| !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();
	5734	+
	5735	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5736	+ if (!alloc.reserve()) return xml_attribute();
	5737	+
	5738	+ xml_attribute a(impl::allocate_attribute(alloc));
	5739	+ if (!a) return xml_attribute();
	5740	+
	5741	+ impl::insert_attribute_after(a._attr, attr._attr, _root);
	5742	+
	5743	+ a.set_name(name_);
	5744	+
	5745	+ return a;
	5746	+ }
	5747	+
	5748	+ PUGI__FN xml_attribute xml_node::insert_attribute_before(const char_t* name_, const xml_attribute& attr)
	5749	+ {
	5750	+ if (!impl::allow_insert_attribute(type())) return xml_attribute();
	5751	+ if (!attr \|\| !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();
	5752	+
	5753	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5754	+ if (!alloc.reserve()) return xml_attribute();
	5755	+
	5756	+ xml_attribute a(impl::allocate_attribute(alloc));
	5757	+ if (!a) return xml_attribute();
	5758	+
	5759	+ impl::insert_attribute_before(a._attr, attr._attr, _root);
	5760	+
	5761	+ a.set_name(name_);
	5762	+
	5763	+ return a;
	5764	+ }
	5765	+
	5766	+ PUGI__FN xml_attribute xml_node::append_copy(const xml_attribute& proto)
	5767	+ {
	5768	+ if (!proto) return xml_attribute();
	5769	+ if (!impl::allow_insert_attribute(type())) return xml_attribute();
	5770	+
	5771	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5772	+ if (!alloc.reserve()) return xml_attribute();
	5773	+
	5774	+ xml_attribute a(impl::allocate_attribute(alloc));
	5775	+ if (!a) return xml_attribute();
	5776	+
	5777	+ impl::append_attribute(a._attr, _root);
	5778	+ impl::node_copy_attribute(a._attr, proto._attr);
	5779	+
	5780	+ return a;
	5781	+ }
	5782	+
	5783	+ PUGI__FN xml_attribute xml_node::prepend_copy(const xml_attribute& proto)
	5784	+ {
	5785	+ if (!proto) return xml_attribute();
	5786	+ if (!impl::allow_insert_attribute(type())) return xml_attribute();
	5787	+
	5788	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5789	+ if (!alloc.reserve()) return xml_attribute();
	5790	+
	5791	+ xml_attribute a(impl::allocate_attribute(alloc));
	5792	+ if (!a) return xml_attribute();
	5793	+
	5794	+ impl::prepend_attribute(a._attr, _root);
	5795	+ impl::node_copy_attribute(a._attr, proto._attr);
	5796	+
	5797	+ return a;
	5798	+ }
	5799	+
	5800	+ PUGI__FN xml_attribute xml_node::insert_copy_after(const xml_attribute& proto, const xml_attribute& attr)
	5801	+ {
	5802	+ if (!proto) return xml_attribute();
	5803	+ if (!impl::allow_insert_attribute(type())) return xml_attribute();
	5804	+ if (!attr \|\| !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();
	5805	+
	5806	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5807	+ if (!alloc.reserve()) return xml_attribute();
	5808	+
	5809	+ xml_attribute a(impl::allocate_attribute(alloc));
	5810	+ if (!a) return xml_attribute();
	5811	+
	5812	+ impl::insert_attribute_after(a._attr, attr._attr, _root);
	5813	+ impl::node_copy_attribute(a._attr, proto._attr);
	5814	+
	5815	+ return a;
	5816	+ }
	5817	+
	5818	+ PUGI__FN xml_attribute xml_node::insert_copy_before(const xml_attribute& proto, const xml_attribute& attr)
	5819	+ {
	5820	+ if (!proto) return xml_attribute();
	5821	+ if (!impl::allow_insert_attribute(type())) return xml_attribute();
	5822	+ if (!attr \|\| !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();
	5823	+
	5824	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5825	+ if (!alloc.reserve()) return xml_attribute();
	5826	+
	5827	+ xml_attribute a(impl::allocate_attribute(alloc));
	5828	+ if (!a) return xml_attribute();
	5829	+
	5830	+ impl::insert_attribute_before(a._attr, attr._attr, _root);
	5831	+ impl::node_copy_attribute(a._attr, proto._attr);
	5832	+
	5833	+ return a;
	5834	+ }
	5835	+
	5836	+ PUGI__FN xml_node xml_node::append_child(xml_node_type type_)
	5837	+ {
	5838	+ if (!impl::allow_insert_child(type(), type_)) return xml_node();
	5839	+
	5840	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5841	+ if (!alloc.reserve()) return xml_node();
	5842	+
	5843	+ xml_node n(impl::allocate_node(alloc, type_));
	5844	+ if (!n) return xml_node();
	5845	+
	5846	+ impl::append_node(n._root, _root);
	5847	+
	5848	+ if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
	5849	+
	5850	+ return n;
	5851	+ }
	5852	+
	5853	+ PUGI__FN xml_node xml_node::prepend_child(xml_node_type type_)
	5854	+ {
	5855	+ if (!impl::allow_insert_child(type(), type_)) return xml_node();
	5856	+
	5857	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5858	+ if (!alloc.reserve()) return xml_node();
	5859	+
	5860	+ xml_node n(impl::allocate_node(alloc, type_));
	5861	+ if (!n) return xml_node();
	5862	+
	5863	+ impl::prepend_node(n._root, _root);
	5864	+
	5865	+ if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
	5866	+
	5867	+ return n;
	5868	+ }
	5869	+
	5870	+ PUGI__FN xml_node xml_node::insert_child_before(xml_node_type type_, const xml_node& node)
	5871	+ {
	5872	+ if (!impl::allow_insert_child(type(), type_)) return xml_node();
	5873	+ if (!node._root \|\| node._root->parent != _root) return xml_node();
	5874	+
	5875	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5876	+ if (!alloc.reserve()) return xml_node();
	5877	+
	5878	+ xml_node n(impl::allocate_node(alloc, type_));
	5879	+ if (!n) return xml_node();
	5880	+
	5881	+ impl::insert_node_before(n._root, node._root);
	5882	+
	5883	+ if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
	5884	+
	5885	+ return n;
	5886	+ }
	5887	+
	5888	+ PUGI__FN xml_node xml_node::insert_child_after(xml_node_type type_, const xml_node& node)
	5889	+ {
	5890	+ if (!impl::allow_insert_child(type(), type_)) return xml_node();
	5891	+ if (!node._root \|\| node._root->parent != _root) return xml_node();
	5892	+
	5893	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5894	+ if (!alloc.reserve()) return xml_node();
	5895	+
	5896	+ xml_node n(impl::allocate_node(alloc, type_));
	5897	+ if (!n) return xml_node();
	5898	+
	5899	+ impl::insert_node_after(n._root, node._root);
	5900	+
	5901	+ if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
	5902	+
	5903	+ return n;
	5904	+ }
	5905	+
	5906	+ PUGI__FN xml_node xml_node::append_child(const char_t* name_)
	5907	+ {
	5908	+ xml_node result = append_child(node_element);
	5909	+
	5910	+ result.set_name(name_);
	5911	+
	5912	+ return result;
	5913	+ }
	5914	+
	5915	+ PUGI__FN xml_node xml_node::prepend_child(const char_t* name_)
	5916	+ {
	5917	+ xml_node result = prepend_child(node_element);
	5918	+
	5919	+ result.set_name(name_);
	5920	+
	5921	+ return result;
	5922	+ }
	5923	+
	5924	+ PUGI__FN xml_node xml_node::insert_child_after(const char_t* name_, const xml_node& node)
	5925	+ {
	5926	+ xml_node result = insert_child_after(node_element, node);
	5927	+
	5928	+ result.set_name(name_);
	5929	+
	5930	+ return result;
	5931	+ }
	5932	+
	5933	+ PUGI__FN xml_node xml_node::insert_child_before(const char_t* name_, const xml_node& node)
	5934	+ {
	5935	+ xml_node result = insert_child_before(node_element, node);
	5936	+
	5937	+ result.set_name(name_);
	5938	+
	5939	+ return result;
	5940	+ }
	5941	+
	5942	+ PUGI__FN xml_node xml_node::append_copy(const xml_node& proto)
	5943	+ {
	5944	+ xml_node_type type_ = proto.type();
	5945	+ if (!impl::allow_insert_child(type(), type_)) return xml_node();
	5946	+
	5947	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5948	+ if (!alloc.reserve()) return xml_node();
	5949	+
	5950	+ xml_node n(impl::allocate_node(alloc, type_));
	5951	+ if (!n) return xml_node();
	5952	+
	5953	+ impl::append_node(n._root, _root);
	5954	+ impl::node_copy_tree(n._root, proto._root);
	5955	+
	5956	+ return n;
	5957	+ }
	5958	+
	5959	+ PUGI__FN xml_node xml_node::prepend_copy(const xml_node& proto)
	5960	+ {
	5961	+ xml_node_type type_ = proto.type();
	5962	+ if (!impl::allow_insert_child(type(), type_)) return xml_node();
	5963	+
	5964	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5965	+ if (!alloc.reserve()) return xml_node();
	5966	+
	5967	+ xml_node n(impl::allocate_node(alloc, type_));
	5968	+ if (!n) return xml_node();
	5969	+
	5970	+ impl::prepend_node(n._root, _root);
	5971	+ impl::node_copy_tree(n._root, proto._root);
	5972	+
	5973	+ return n;
	5974	+ }
	5975	+
	5976	+ PUGI__FN xml_node xml_node::insert_copy_after(const xml_node& proto, const xml_node& node)
	5977	+ {
	5978	+ xml_node_type type_ = proto.type();
	5979	+ if (!impl::allow_insert_child(type(), type_)) return xml_node();
	5980	+ if (!node._root \|\| node._root->parent != _root) return xml_node();
	5981	+
	5982	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	5983	+ if (!alloc.reserve()) return xml_node();
	5984	+
	5985	+ xml_node n(impl::allocate_node(alloc, type_));
	5986	+ if (!n) return xml_node();
	5987	+
	5988	+ impl::insert_node_after(n._root, node._root);
	5989	+ impl::node_copy_tree(n._root, proto._root);
	5990	+
	5991	+ return n;
	5992	+ }
	5993	+
	5994	+ PUGI__FN xml_node xml_node::insert_copy_before(const xml_node& proto, const xml_node& node)
	5995	+ {
	5996	+ xml_node_type type_ = proto.type();
	5997	+ if (!impl::allow_insert_child(type(), type_)) return xml_node();
	5998	+ if (!node._root \|\| node._root->parent != _root) return xml_node();
	5999	+
	6000	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	6001	+ if (!alloc.reserve()) return xml_node();
	6002	+
	6003	+ xml_node n(impl::allocate_node(alloc, type_));
	6004	+ if (!n) return xml_node();
	6005	+
	6006	+ impl::insert_node_before(n._root, node._root);
	6007	+ impl::node_copy_tree(n._root, proto._root);
	6008	+
	6009	+ return n;
	6010	+ }
	6011	+
	6012	+ PUGI__FN xml_node xml_node::append_move(const xml_node& moved)
	6013	+ {
	6014	+ if (!impl::allow_move(*this, moved)) return xml_node();
	6015	+
	6016	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	6017	+ if (!alloc.reserve()) return xml_node();
	6018	+
	6019	+ // disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
	6020	+ impl::get_document(_root).header \|= impl::xml_memory_page_contents_shared_mask;
	6021	+
	6022	+ impl::remove_node(moved._root);
	6023	+ impl::append_node(moved._root, _root);
	6024	+
	6025	+ return moved;
	6026	+ }
	6027	+
	6028	+ PUGI__FN xml_node xml_node::prepend_move(const xml_node& moved)
	6029	+ {
	6030	+ if (!impl::allow_move(*this, moved)) return xml_node();
	6031	+
	6032	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	6033	+ if (!alloc.reserve()) return xml_node();
	6034	+
	6035	+ // disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
	6036	+ impl::get_document(_root).header \|= impl::xml_memory_page_contents_shared_mask;
	6037	+
	6038	+ impl::remove_node(moved._root);
	6039	+ impl::prepend_node(moved._root, _root);
	6040	+
	6041	+ return moved;
	6042	+ }
	6043	+
	6044	+ PUGI__FN xml_node xml_node::insert_move_after(const xml_node& moved, const xml_node& node)
	6045	+ {
	6046	+ if (!impl::allow_move(*this, moved)) return xml_node();
	6047	+ if (!node._root \|\| node._root->parent != _root) return xml_node();
	6048	+ if (moved._root == node._root) return xml_node();
	6049	+
	6050	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	6051	+ if (!alloc.reserve()) return xml_node();
	6052	+
	6053	+ // disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
	6054	+ impl::get_document(_root).header \|= impl::xml_memory_page_contents_shared_mask;
	6055	+
	6056	+ impl::remove_node(moved._root);
	6057	+ impl::insert_node_after(moved._root, node._root);
	6058	+
	6059	+ return moved;
	6060	+ }
	6061	+
	6062	+ PUGI__FN xml_node xml_node::insert_move_before(const xml_node& moved, const xml_node& node)
	6063	+ {
	6064	+ if (!impl::allow_move(*this, moved)) return xml_node();
	6065	+ if (!node._root \|\| node._root->parent != _root) return xml_node();
	6066	+ if (moved._root == node._root) return xml_node();
	6067	+
	6068	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	6069	+ if (!alloc.reserve()) return xml_node();
	6070	+
	6071	+ // disable document_buffer_order optimization since moving nodes around changes document order without changing buffer pointers
	6072	+ impl::get_document(_root).header \|= impl::xml_memory_page_contents_shared_mask;
	6073	+
	6074	+ impl::remove_node(moved._root);
	6075	+ impl::insert_node_before(moved._root, node._root);
	6076	+
	6077	+ return moved;
	6078	+ }
	6079	+
	6080	+ PUGI__FN bool xml_node::remove_attribute(const char_t* name_)
	6081	+ {
	6082	+ return remove_attribute(attribute(name_));
	6083	+ }
	6084	+
	6085	+ PUGI__FN bool xml_node::remove_attribute(const xml_attribute& a)
	6086	+ {
	6087	+ if (!_root \|\| !a._attr) return false;
	6088	+ if (!impl::is_attribute_of(a._attr, _root)) return false;
	6089	+
	6090	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	6091	+ if (!alloc.reserve()) return false;
	6092	+
	6093	+ impl::remove_attribute(a._attr, _root);
	6094	+ impl::destroy_attribute(a._attr, alloc);
	6095	+
	6096	+ return true;
	6097	+ }
	6098	+
	6099	+ PUGI__FN bool xml_node::remove_attributes()
	6100	+ {
	6101	+ if (!_root) return false;
	6102	+
	6103	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	6104	+ if (!alloc.reserve()) return false;
	6105	+
	6106	+ for (xml_attribute_struct* attr = _root->first_attribute; attr; )
	6107	+ {
	6108	+ xml_attribute_struct* next = attr->next_attribute;
	6109	+
	6110	+ impl::destroy_attribute(attr, alloc);
	6111	+
	6112	+ attr = next;
	6113	+ }
	6114	+
	6115	+ _root->first_attribute = 0;
	6116	+
	6117	+ return true;
	6118	+ }
	6119	+
	6120	+ PUGI__FN bool xml_node::remove_child(const char_t* name_)
	6121	+ {
	6122	+ return remove_child(child(name_));
	6123	+ }
	6124	+
	6125	+ PUGI__FN bool xml_node::remove_child(const xml_node& n)
	6126	+ {
	6127	+ if (!_root \|\| !n._root \|\| n._root->parent != _root) return false;
	6128	+
	6129	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	6130	+ if (!alloc.reserve()) return false;
	6131	+
	6132	+ impl::remove_node(n._root);
	6133	+ impl::destroy_node(n._root, alloc);
	6134	+
	6135	+ return true;
	6136	+ }
	6137	+
	6138	+ PUGI__FN bool xml_node::remove_children()
	6139	+ {
	6140	+ if (!_root) return false;
	6141	+
	6142	+ impl::xml_allocator& alloc = impl::get_allocator(_root);
	6143	+ if (!alloc.reserve()) return false;
	6144	+
	6145	+ for (xml_node_struct* cur = _root->first_child; cur; )
	6146	+ {
	6147	+ xml_node_struct* next = cur->next_sibling;
	6148	+
	6149	+ impl::destroy_node(cur, alloc);
	6150	+
	6151	+ cur = next;
	6152	+ }
	6153	+
	6154	+ _root->first_child = 0;
	6155	+
	6156	+ return true;
	6157	+ }
	6158	+
	6159	+ PUGI__FN xml_parse_result xml_node::append_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding)
	6160	+ {
	6161	+ // append_buffer is only valid for elements/documents
	6162	+ if (!impl::allow_insert_child(type(), node_element)) return impl::make_parse_result(status_append_invalid_root);
	6163	+
	6164	+ // get document node
	6165	+ impl::xml_document_struct* doc = &impl::get_document(_root);
	6166	+
	6167	+ // disable document_buffer_order optimization since in a document with multiple buffers comparing buffer pointers does not make sense
	6168	+ doc->header \|= impl::xml_memory_page_contents_shared_mask;
	6169	+
	6170	+ // get extra buffer element (we'll store the document fragment buffer there so that we can deallocate it later)
	6171	+ impl::xml_memory_page* page = 0;
	6172	+ impl::xml_extra_buffer* extra = static_cast<impl::xml_extra_buffer>(doc->allocate_memory(sizeof(impl::xml_extra_buffer) + sizeof(void), page));
	6173	+ (void)page;
	6174	+
	6175	+ if (!extra) return impl::make_parse_result(status_out_of_memory);
	6176	+
	6177	+ #ifdef PUGIXML_COMPACT
	6178	+ // align the memory block to a pointer boundary; this is required for compact mode where memory allocations are only 4b aligned
	6179	+ // note that this requires up to sizeof(void*)-1 additional memory, which the allocation above takes into account
	6180	+ extra = reinterpret_cast<impl::xml_extra_buffer>((reinterpret_cast<uintptr_t>(extra) + (sizeof(void) - 1)) & ~(sizeof(void*) - 1));
	6181	+ #endif
	6182	+
	6183	+ // add extra buffer to the list
	6184	+ extra->buffer = 0;
	6185	+ extra->next = doc->extra_buffers;
	6186	+ doc->extra_buffers = extra;
	6187	+
	6188	+ // name of the root has to be NULL before parsing - otherwise closing node mismatches will not be detected at the top level
	6189	+ impl::name_null_sentry sentry(_root);
	6190	+
	6191	+ return impl::load_buffer_impl(doc, _root, const_cast<void*>(contents), size, options, encoding, false, false, &extra->buffer);
	6192	+ }
	6193	+
	6194	+ PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* name_, const char_t* attr_name, const char_t* attr_value) const
	6195	+ {
	6196	+ if (!_root) return xml_node();
	6197	+
	6198	+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
	6199	+ if (i->name && impl::strequal(name_, i->name))
	6200	+ {
	6201	+ for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
	6202	+ if (a->name && impl::strequal(attr_name, a->name) && impl::strequal(attr_value, a->value ? a->value + 0 : PUGIXML_TEXT("")))
	6203	+ return xml_node(i);
	6204	+ }
	6205	+
	6206	+ return xml_node();
	6207	+ }
	6208	+
	6209	+ PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const
	6210	+ {
	6211	+ if (!_root) return xml_node();
	6212	+
	6213	+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
	6214	+ for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
	6215	+ if (a->name && impl::strequal(attr_name, a->name) && impl::strequal(attr_value, a->value ? a->value + 0 : PUGIXML_TEXT("")))
	6216	+ return xml_node(i);
	6217	+
	6218	+ return xml_node();
	6219	+ }
	6220	+
	6221	+#ifndef PUGIXML_NO_STL
	6222	+ PUGI__FN string_t xml_node::path(char_t delimiter) const
	6223	+ {
	6224	+ if (!_root) return string_t();
	6225	+
	6226	+ size_t offset = 0;
	6227	+
	6228	+ for (xml_node_struct* i = _root; i; i = i->parent)
	6229	+ {
	6230	+ offset += (i != _root);
	6231	+ offset += i->name ? impl::strlength(i->name) : 0;
	6232	+ }
	6233	+
	6234	+ string_t result;
	6235	+ result.resize(offset);
	6236	+
	6237	+ for (xml_node_struct* j = _root; j; j = j->parent)
	6238	+ {
	6239	+ if (j != _root)
	6240	+ result[--offset] = delimiter;
	6241	+
	6242	+ if (j->name)
	6243	+ {
	6244	+ size_t length = impl::strlength(j->name);
	6245	+
	6246	+ offset -= length;
	6247	+ memcpy(&result[offset], j->name, length * sizeof(char_t));
	6248	+ }
	6249	+ }
	6250	+
	6251	+ assert(offset == 0);
	6252	+
	6253	+ return result;
	6254	+ }
	6255	+#endif
	6256	+
	6257	+ PUGI__FN xml_node xml_node::first_element_by_path(const char_t* path_, char_t delimiter) const
	6258	+ {
	6259	+ xml_node context = path_[0] == delimiter ? root() : *this;
	6260	+
	6261	+ if (!context._root) return xml_node();
	6262	+
	6263	+ const char_t* path_segment = path_;
	6264	+
	6265	+ while (*path_segment == delimiter) ++path_segment;
	6266	+
	6267	+ const char_t* path_segment_end = path_segment;
	6268	+
	6269	+ while (path_segment_end && path_segment_end != delimiter) ++path_segment_end;
	6270	+
	6271	+ if (path_segment == path_segment_end) return context;
	6272	+
	6273	+ const char_t* next_segment = path_segment_end;
	6274	+
	6275	+ while (*next_segment == delimiter) ++next_segment;
	6276	+
	6277	+ if (*path_segment == '.' && path_segment + 1 == path_segment_end)
	6278	+ return context.first_element_by_path(next_segment, delimiter);
	6279	+ else if (path_segment == '.' && (path_segment+1) == '.' && path_segment + 2 == path_segment_end)
	6280	+ return context.parent().first_element_by_path(next_segment, delimiter);
	6281	+ else
	6282	+ {
	6283	+ for (xml_node_struct* j = context._root->first_child; j; j = j->next_sibling)
	6284	+ {
	6285	+ if (j->name && impl::strequalrange(j->name, path_segment, static_cast<size_t>(path_segment_end - path_segment)))
	6286	+ {
	6287	+ xml_node subsearch = xml_node(j).first_element_by_path(next_segment, delimiter);
	6288	+
	6289	+ if (subsearch) return subsearch;
	6290	+ }
	6291	+ }
	6292	+
	6293	+ return xml_node();
	6294	+ }
	6295	+ }
	6296	+
	6297	+ PUGI__FN bool xml_node::traverse(xml_tree_walker& walker)
	6298	+ {
	6299	+ walker._depth = -1;
	6300	+
	6301	+ xml_node arg_begin(_root);
	6302	+ if (!walker.begin(arg_begin)) return false;
	6303	+
	6304	+ xml_node_struct* cur = _root ? _root->first_child + 0 : 0;
	6305	+
	6306	+ if (cur)
	6307	+ {
	6308	+ ++walker._depth;
	6309	+
	6310	+ do
	6311	+ {
	6312	+ xml_node arg_for_each(cur);
	6313	+ if (!walker.for_each(arg_for_each))
	6314	+ return false;
	6315	+
	6316	+ if (cur->first_child)
	6317	+ {
	6318	+ ++walker._depth;
	6319	+ cur = cur->first_child;
	6320	+ }
	6321	+ else if (cur->next_sibling)
	6322	+ cur = cur->next_sibling;
	6323	+ else
	6324	+ {
	6325	+ while (!cur->next_sibling && cur != _root && cur->parent)
	6326	+ {
	6327	+ --walker._depth;
	6328	+ cur = cur->parent;
	6329	+ }
	6330	+
	6331	+ if (cur != _root)
	6332	+ cur = cur->next_sibling;
	6333	+ }
	6334	+ }
	6335	+ while (cur && cur != _root);
	6336	+ }
	6337	+
	6338	+ assert(walker._depth == -1);
	6339	+
	6340	+ xml_node arg_end(_root);
	6341	+ return walker.end(arg_end);
	6342	+ }
	6343	+
	6344	+ PUGI__FN size_t xml_node::hash_value() const
	6345	+ {
	6346	+ return static_cast<size_t>(reinterpret_cast<uintptr_t>(_root) / sizeof(xml_node_struct));
	6347	+ }
	6348	+
	6349	+ PUGI__FN xml_node_struct* xml_node::internal_object() const
	6350	+ {
	6351	+ return _root;
	6352	+ }
	6353	+
	6354	+ PUGI__FN void xml_node::print(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
	6355	+ {
	6356	+ if (!_root) return;
	6357	+
	6358	+ impl::xml_buffered_writer buffered_writer(writer, encoding);
	6359	+
	6360	+ impl::node_output(buffered_writer, _root, indent, flags, depth);
	6361	+
	6362	+ buffered_writer.flush();
	6363	+ }
	6364	+
	6365	+#ifndef PUGIXML_NO_STL
	6366	+ PUGI__FN void xml_node::print(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
	6367	+ {
	6368	+ xml_writer_stream writer(stream);
	6369	+
	6370	+ print(writer, indent, flags, encoding, depth);
	6371	+ }
	6372	+
	6373	+ PUGI__FN void xml_node::print(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent, unsigned int flags, unsigned int depth) const
	6374	+ {
	6375	+ xml_writer_stream writer(stream);
	6376	+
	6377	+ print(writer, indent, flags, encoding_wchar, depth);
	6378	+ }
	6379	+#endif
	6380	+
	6381	+ PUGI__FN ptrdiff_t xml_node::offset_debug() const
	6382	+ {
	6383	+ if (!_root) return -1;
	6384	+
	6385	+ impl::xml_document_struct& doc = impl::get_document(_root);
	6386	+
	6387	+ // we can determine the offset reliably only if there is exactly once parse buffer
	6388	+ if (!doc.buffer \|\| doc.extra_buffers) return -1;
	6389	+
	6390	+ switch (type())
	6391	+ {
	6392	+ case node_document:
	6393	+ return 0;
	6394	+
	6395	+ case node_element:
	6396	+ case node_declaration:
	6397	+ case node_pi:
	6398	+ return _root->name && (_root->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0 ? _root->name - doc.buffer : -1;
	6399	+
	6400	+ case node_pcdata:
	6401	+ case node_cdata:
	6402	+ case node_comment:
	6403	+ case node_doctype:
	6404	+ return _root->value && (_root->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0 ? _root->value - doc.buffer : -1;
	6405	+
	6406	+ default:
	6407	+ assert(false && "Invalid node type"); // unreachable
	6408	+ return -1;
	6409	+ }
	6410	+ }
	6411	+
	6412	+#ifdef __BORLANDC__
	6413	+ PUGI__FN bool operator&&(const xml_node& lhs, bool rhs)
	6414	+ {
	6415	+ return (bool)lhs && rhs;
	6416	+ }
	6417	+
	6418	+ PUGI__FN bool operator\|\|(const xml_node& lhs, bool rhs)
	6419	+ {
	6420	+ return (bool)lhs \|\| rhs;
	6421	+ }
	6422	+#endif
	6423	+
	6424	+ PUGI__FN xml_text::xml_text(xml_node_struct* root): _root(root)
	6425	+ {
	6426	+ }
	6427	+
	6428	+ PUGI__FN xml_node_struct* xml_text::_data() const
	6429	+ {
	6430	+ if (!_root \|\| impl::is_text_node(_root)) return _root;
	6431	+
	6432	+ // element nodes can have value if parse_embed_pcdata was used
	6433	+ if (PUGI__NODETYPE(_root) == node_element && _root->value)
	6434	+ return _root;
	6435	+
	6436	+ for (xml_node_struct* node = _root->first_child; node; node = node->next_sibling)
	6437	+ if (impl::is_text_node(node))
	6438	+ return node;
	6439	+
	6440	+ return 0;
	6441	+ }
	6442	+
	6443	+ PUGI__FN xml_node_struct* xml_text::_data_new()
	6444	+ {
	6445	+ xml_node_struct* d = _data();
	6446	+ if (d) return d;
	6447	+
	6448	+ return xml_node(_root).append_child(node_pcdata).internal_object();
	6449	+ }
	6450	+
	6451	+ PUGI__FN xml_text::xml_text(): _root(0)
	6452	+ {
	6453	+ }
	6454	+
	6455	+ PUGI__FN static void unspecified_bool_xml_text(xml_text***)
	6456	+ {
	6457	+ }
	6458	+
	6459	+ PUGI__FN xml_text::operator xml_text::unspecified_bool_type() const
	6460	+ {
	6461	+ return _data() ? unspecified_bool_xml_text : 0;
	6462	+ }
	6463	+
	6464	+ PUGI__FN bool xml_text::operator!() const
	6465	+ {
	6466	+ return !_data();
	6467	+ }
	6468	+
	6469	+ PUGI__FN bool xml_text::empty() const
	6470	+ {
	6471	+ return _data() == 0;
	6472	+ }
	6473	+
	6474	+ PUGI__FN const char_t* xml_text::get() const
	6475	+ {
	6476	+ xml_node_struct* d = _data();
	6477	+
	6478	+ return (d && d->value) ? d->value + 0 : PUGIXML_TEXT("");
	6479	+ }
	6480	+
	6481	+ PUGI__FN const char_t* xml_text::as_string(const char_t* def) const
	6482	+ {
	6483	+ xml_node_struct* d = _data();
	6484	+
	6485	+ return (d && d->value) ? d->value + 0 : def;
	6486	+ }
	6487	+
	6488	+ PUGI__FN int xml_text::as_int(int def) const
	6489	+ {
	6490	+ xml_node_struct* d = _data();
	6491	+
	6492	+ return (d && d->value) ? impl::get_value_int(d->value) : def;
	6493	+ }
	6494	+
	6495	+ PUGI__FN unsigned int xml_text::as_uint(unsigned int def) const
	6496	+ {
	6497	+ xml_node_struct* d = _data();
	6498	+
	6499	+ return (d && d->value) ? impl::get_value_uint(d->value) : def;
	6500	+ }
	6501	+
	6502	+ PUGI__FN double xml_text::as_double(double def) const
	6503	+ {
	6504	+ xml_node_struct* d = _data();
	6505	+
	6506	+ return (d && d->value) ? impl::get_value_double(d->value) : def;
	6507	+ }
	6508	+
	6509	+ PUGI__FN float xml_text::as_float(float def) const
	6510	+ {
	6511	+ xml_node_struct* d = _data();
	6512	+
	6513	+ return (d && d->value) ? impl::get_value_float(d->value) : def;
	6514	+ }
	6515	+
	6516	+ PUGI__FN bool xml_text::as_bool(bool def) const
	6517	+ {
	6518	+ xml_node_struct* d = _data();
	6519	+
	6520	+ return (d && d->value) ? impl::get_value_bool(d->value) : def;
	6521	+ }
	6522	+
	6523	+#ifdef PUGIXML_HAS_LONG_LONG
	6524	+ PUGI__FN long long xml_text::as_llong(long long def) const
	6525	+ {
	6526	+ xml_node_struct* d = _data();
	6527	+
	6528	+ return (d && d->value) ? impl::get_value_llong(d->value) : def;
	6529	+ }
	6530	+
	6531	+ PUGI__FN unsigned long long xml_text::as_ullong(unsigned long long def) const
	6532	+ {
	6533	+ xml_node_struct* d = _data();
	6534	+
	6535	+ return (d && d->value) ? impl::get_value_ullong(d->value) : def;
	6536	+ }
	6537	+#endif
	6538	+
	6539	+ PUGI__FN bool xml_text::set(const char_t* rhs)
	6540	+ {
	6541	+ xml_node_struct* dn = _data_new();
	6542	+
	6543	+ return dn ? impl::strcpy_insitu(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, impl::strlength(rhs)) : false;
	6544	+ }
	6545	+
	6546	+ PUGI__FN bool xml_text::set(int rhs)
	6547	+ {
	6548	+ xml_node_struct* dn = _data_new();
	6549	+
	6550	+ return dn ? impl::set_value_integer<unsigned int>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0) : false;
	6551	+ }
	6552	+
	6553	+ PUGI__FN bool xml_text::set(unsigned int rhs)
	6554	+ {
	6555	+ xml_node_struct* dn = _data_new();
	6556	+
	6557	+ return dn ? impl::set_value_integer<unsigned int>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, false) : false;
	6558	+ }
	6559	+
	6560	+ PUGI__FN bool xml_text::set(long rhs)
	6561	+ {
	6562	+ xml_node_struct* dn = _data_new();
	6563	+
	6564	+ return dn ? impl::set_value_integer<unsigned long>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0) : false;
	6565	+ }
	6566	+
	6567	+ PUGI__FN bool xml_text::set(unsigned long rhs)
	6568	+ {
	6569	+ xml_node_struct* dn = _data_new();
	6570	+
	6571	+ return dn ? impl::set_value_integer<unsigned long>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, false) : false;
	6572	+ }
	6573	+
	6574	+ PUGI__FN bool xml_text::set(float rhs)
	6575	+ {
	6576	+ xml_node_struct* dn = _data_new();
	6577	+
	6578	+ return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, default_float_precision) : false;
	6579	+ }
	6580	+
	6581	+ PUGI__FN bool xml_text::set(float rhs, int precision)
	6582	+ {
	6583	+ xml_node_struct* dn = _data_new();
	6584	+
	6585	+ return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, precision) : false;
	6586	+ }
	6587	+
	6588	+ PUGI__FN bool xml_text::set(double rhs)
	6589	+ {
	6590	+ xml_node_struct* dn = _data_new();
	6591	+
	6592	+ return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, default_double_precision) : false;
	6593	+ }
	6594	+
	6595	+ PUGI__FN bool xml_text::set(double rhs, int precision)
	6596	+ {
	6597	+ xml_node_struct* dn = _data_new();
	6598	+
	6599	+ return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, precision) : false;
	6600	+ }
	6601	+
	6602	+ PUGI__FN bool xml_text::set(bool rhs)
	6603	+ {
	6604	+ xml_node_struct* dn = _data_new();
	6605	+
	6606	+ return dn ? impl::set_value_bool(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
	6607	+ }
	6608	+
	6609	+#ifdef PUGIXML_HAS_LONG_LONG
	6610	+ PUGI__FN bool xml_text::set(long long rhs)
	6611	+ {
	6612	+ xml_node_struct* dn = _data_new();
	6613	+
	6614	+ return dn ? impl::set_value_integer<unsigned long long>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, rhs < 0) : false;
	6615	+ }
	6616	+
	6617	+ PUGI__FN bool xml_text::set(unsigned long long rhs)
	6618	+ {
	6619	+ xml_node_struct* dn = _data_new();
	6620	+
	6621	+ return dn ? impl::set_value_integer<unsigned long long>(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs, false) : false;
	6622	+ }
	6623	+#endif
	6624	+
	6625	+ PUGI__FN xml_text& xml_text::operator=(const char_t* rhs)
	6626	+ {
	6627	+ set(rhs);
	6628	+ return *this;
	6629	+ }
	6630	+
	6631	+ PUGI__FN xml_text& xml_text::operator=(int rhs)
	6632	+ {
	6633	+ set(rhs);
	6634	+ return *this;
	6635	+ }
	6636	+
	6637	+ PUGI__FN xml_text& xml_text::operator=(unsigned int rhs)
	6638	+ {
	6639	+ set(rhs);
	6640	+ return *this;
	6641	+ }
	6642	+
	6643	+ PUGI__FN xml_text& xml_text::operator=(long rhs)
	6644	+ {
	6645	+ set(rhs);
	6646	+ return *this;
	6647	+ }
	6648	+
	6649	+ PUGI__FN xml_text& xml_text::operator=(unsigned long rhs)
	6650	+ {
	6651	+ set(rhs);
	6652	+ return *this;
	6653	+ }
	6654	+
	6655	+ PUGI__FN xml_text& xml_text::operator=(double rhs)
	6656	+ {
	6657	+ set(rhs);
	6658	+ return *this;
	6659	+ }
	6660	+
	6661	+ PUGI__FN xml_text& xml_text::operator=(float rhs)
	6662	+ {
	6663	+ set(rhs);
	6664	+ return *this;
	6665	+ }
	6666	+
	6667	+ PUGI__FN xml_text& xml_text::operator=(bool rhs)
	6668	+ {
	6669	+ set(rhs);
	6670	+ return *this;
	6671	+ }
	6672	+
	6673	+#ifdef PUGIXML_HAS_LONG_LONG
	6674	+ PUGI__FN xml_text& xml_text::operator=(long long rhs)
	6675	+ {
	6676	+ set(rhs);
	6677	+ return *this;
	6678	+ }
	6679	+
	6680	+ PUGI__FN xml_text& xml_text::operator=(unsigned long long rhs)
	6681	+ {
	6682	+ set(rhs);
	6683	+ return *this;
	6684	+ }
	6685	+#endif
	6686	+
	6687	+ PUGI__FN xml_node xml_text::data() const
	6688	+ {
	6689	+ return xml_node(_data());
	6690	+ }
	6691	+
	6692	+#ifdef __BORLANDC__
	6693	+ PUGI__FN bool operator&&(const xml_text& lhs, bool rhs)
	6694	+ {
	6695	+ return (bool)lhs && rhs;
	6696	+ }
	6697	+
	6698	+ PUGI__FN bool operator\|\|(const xml_text& lhs, bool rhs)
	6699	+ {
	6700	+ return (bool)lhs \|\| rhs;
	6701	+ }
	6702	+#endif
	6703	+
	6704	+ PUGI__FN xml_node_iterator::xml_node_iterator()
	6705	+ {
	6706	+ }
	6707	+
	6708	+ PUGI__FN xml_node_iterator::xml_node_iterator(const xml_node& node): _wrap(node), _parent(node.parent())
	6709	+ {
	6710	+ }
	6711	+
	6712	+ PUGI__FN xml_node_iterator::xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent)
	6713	+ {
	6714	+ }
	6715	+
	6716	+ PUGI__FN bool xml_node_iterator::operator==(const xml_node_iterator& rhs) const
	6717	+ {
	6718	+ return _wrap._root == rhs._wrap._root && _parent._root == rhs._parent._root;
	6719	+ }
	6720	+
	6721	+ PUGI__FN bool xml_node_iterator::operator!=(const xml_node_iterator& rhs) const
	6722	+ {
	6723	+ return _wrap._root != rhs._wrap._root \|\| _parent._root != rhs._parent._root;
	6724	+ }
	6725	+
	6726	+ PUGI__FN xml_node& xml_node_iterator::operator*() const
	6727	+ {
	6728	+ assert(_wrap._root);
	6729	+ return _wrap;
	6730	+ }
	6731	+
	6732	+ PUGI__FN xml_node* xml_node_iterator::operator->() const
	6733	+ {
	6734	+ assert(_wrap._root);
	6735	+ return const_cast<xml_node*>(&_wrap); // BCC5 workaround
	6736	+ }
	6737	+
	6738	+ PUGI__FN const xml_node_iterator& xml_node_iterator::operator++()
	6739	+ {
	6740	+ assert(_wrap._root);
	6741	+ _wrap._root = _wrap._root->next_sibling;
	6742	+ return *this;
	6743	+ }
	6744	+
	6745	+ PUGI__FN xml_node_iterator xml_node_iterator::operator++(int)
	6746	+ {
	6747	+ xml_node_iterator temp = *this;
	6748	+ ++*this;
	6749	+ return temp;
	6750	+ }
	6751	+
	6752	+ PUGI__FN const xml_node_iterator& xml_node_iterator::operator--()
	6753	+ {
	6754	+ _wrap = _wrap._root ? _wrap.previous_sibling() : _parent.last_child();
	6755	+ return *this;
	6756	+ }
	6757	+
	6758	+ PUGI__FN xml_node_iterator xml_node_iterator::operator--(int)
	6759	+ {
	6760	+ xml_node_iterator temp = *this;
	6761	+ --*this;
	6762	+ return temp;
	6763	+ }
	6764	+
	6765	+ PUGI__FN xml_attribute_iterator::xml_attribute_iterator()
	6766	+ {
	6767	+ }
	6768	+
	6769	+ PUGI__FN xml_attribute_iterator::xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent): _wrap(attr), _parent(parent)
	6770	+ {
	6771	+ }
	6772	+
	6773	+ PUGI__FN xml_attribute_iterator::xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent)
	6774	+ {
	6775	+ }
	6776	+
	6777	+ PUGI__FN bool xml_attribute_iterator::operator==(const xml_attribute_iterator& rhs) const
	6778	+ {
	6779	+ return _wrap._attr == rhs._wrap._attr && _parent._root == rhs._parent._root;
	6780	+ }
	6781	+
	6782	+ PUGI__FN bool xml_attribute_iterator::operator!=(const xml_attribute_iterator& rhs) const
	6783	+ {
	6784	+ return _wrap._attr != rhs._wrap._attr \|\| _parent._root != rhs._parent._root;
	6785	+ }
	6786	+
	6787	+ PUGI__FN xml_attribute& xml_attribute_iterator::operator*() const
	6788	+ {
	6789	+ assert(_wrap._attr);
	6790	+ return _wrap;
	6791	+ }
	6792	+
	6793	+ PUGI__FN xml_attribute* xml_attribute_iterator::operator->() const
	6794	+ {
	6795	+ assert(_wrap._attr);
	6796	+ return const_cast<xml_attribute*>(&_wrap); // BCC5 workaround
	6797	+ }
	6798	+
	6799	+ PUGI__FN const xml_attribute_iterator& xml_attribute_iterator::operator++()
	6800	+ {
	6801	+ assert(_wrap._attr);
	6802	+ _wrap._attr = _wrap._attr->next_attribute;
	6803	+ return *this;
	6804	+ }
	6805	+
	6806	+ PUGI__FN xml_attribute_iterator xml_attribute_iterator::operator++(int)
	6807	+ {
	6808	+ xml_attribute_iterator temp = *this;
	6809	+ ++*this;
	6810	+ return temp;
	6811	+ }
	6812	+
	6813	+ PUGI__FN const xml_attribute_iterator& xml_attribute_iterator::operator--()
	6814	+ {
	6815	+ _wrap = _wrap._attr ? _wrap.previous_attribute() : _parent.last_attribute();
	6816	+ return *this;
	6817	+ }
	6818	+
	6819	+ PUGI__FN xml_attribute_iterator xml_attribute_iterator::operator--(int)
	6820	+ {
	6821	+ xml_attribute_iterator temp = *this;
	6822	+ --*this;
	6823	+ return temp;
	6824	+ }
	6825	+
	6826	+ PUGI__FN xml_named_node_iterator::xml_named_node_iterator(): _name(0)
	6827	+ {
	6828	+ }
	6829	+
	6830	+ PUGI__FN xml_named_node_iterator::xml_named_node_iterator(const xml_node& node, const char_t* name): _wrap(node), _parent(node.parent()), _name(name)
	6831	+ {
	6832	+ }
	6833	+
	6834	+ PUGI__FN xml_named_node_iterator::xml_named_node_iterator(xml_node_struct* ref, xml_node_struct* parent, const char_t* name): _wrap(ref), _parent(parent), _name(name)
	6835	+ {
	6836	+ }
	6837	+
	6838	+ PUGI__FN bool xml_named_node_iterator::operator==(const xml_named_node_iterator& rhs) const
	6839	+ {
	6840	+ return _wrap._root == rhs._wrap._root && _parent._root == rhs._parent._root;
	6841	+ }
	6842	+
	6843	+ PUGI__FN bool xml_named_node_iterator::operator!=(const xml_named_node_iterator& rhs) const
	6844	+ {
	6845	+ return _wrap._root != rhs._wrap._root \|\| _parent._root != rhs._parent._root;
	6846	+ }
	6847	+
	6848	+ PUGI__FN xml_node& xml_named_node_iterator::operator*() const
	6849	+ {
	6850	+ assert(_wrap._root);
	6851	+ return _wrap;
	6852	+ }
	6853	+
	6854	+ PUGI__FN xml_node* xml_named_node_iterator::operator->() const
	6855	+ {
	6856	+ assert(_wrap._root);
	6857	+ return const_cast<xml_node*>(&_wrap); // BCC5 workaround
	6858	+ }
	6859	+
	6860	+ PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator++()
	6861	+ {
	6862	+ assert(_wrap._root);
	6863	+ _wrap = _wrap.next_sibling(_name);
	6864	+ return *this;
	6865	+ }
	6866	+
	6867	+ PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator++(int)
	6868	+ {
	6869	+ xml_named_node_iterator temp = *this;
	6870	+ ++*this;
	6871	+ return temp;
	6872	+ }
	6873	+
	6874	+ PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator--()
	6875	+ {
	6876	+ if (_wrap._root)
	6877	+ _wrap = _wrap.previous_sibling(_name);
	6878	+ else
	6879	+ {
	6880	+ _wrap = _parent.last_child();
	6881	+
	6882	+ if (!impl::strequal(_wrap.name(), _name))
	6883	+ _wrap = _wrap.previous_sibling(_name);
	6884	+ }
	6885	+
	6886	+ return *this;
	6887	+ }
	6888	+
	6889	+ PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator--(int)
	6890	+ {
	6891	+ xml_named_node_iterator temp = *this;
	6892	+ --*this;
	6893	+ return temp;
	6894	+ }
	6895	+
	6896	+ PUGI__FN xml_parse_result::xml_parse_result(): status(status_internal_error), offset(0), encoding(encoding_auto)
	6897	+ {
	6898	+ }
	6899	+
	6900	+ PUGI__FN xml_parse_result::operator bool() const
	6901	+ {
	6902	+ return status == status_ok;
	6903	+ }
	6904	+
	6905	+ PUGI__FN const char* xml_parse_result::description() const
	6906	+ {
	6907	+ switch (status)
	6908	+ {
	6909	+ case status_ok: return "No error";
	6910	+
	6911	+ case status_file_not_found: return "File was not found";
	6912	+ case status_io_error: return "Error reading from file/stream";
	6913	+ case status_out_of_memory: return "Could not allocate memory";
	6914	+ case status_internal_error: return "Internal error occurred";
	6915	+
	6916	+ case status_unrecognized_tag: return "Could not determine tag type";
	6917	+
	6918	+ case status_bad_pi: return "Error parsing document declaration/processing instruction";
	6919	+ case status_bad_comment: return "Error parsing comment";
	6920	+ case status_bad_cdata: return "Error parsing CDATA section";
	6921	+ case status_bad_doctype: return "Error parsing document type declaration";
	6922	+ case status_bad_pcdata: return "Error parsing PCDATA section";
	6923	+ case status_bad_start_element: return "Error parsing start element tag";
	6924	+ case status_bad_attribute: return "Error parsing element attribute";
	6925	+ case status_bad_end_element: return "Error parsing end element tag";
	6926	+ case status_end_element_mismatch: return "Start-end tags mismatch";
	6927	+
	6928	+ case status_append_invalid_root: return "Unable to append nodes: root is not an element or document";
	6929	+
	6930	+ case status_no_document_element: return "No document element found";
	6931	+
	6932	+ default: return "Unknown error";
	6933	+ }
	6934	+ }
	6935	+
	6936	+ PUGI__FN xml_document::xml_document(): _buffer(0)
	6937	+ {
	6938	+ _create();
	6939	+ }
	6940	+
	6941	+ PUGI__FN xml_document::~xml_document()
	6942	+ {
	6943	+ _destroy();
	6944	+ }
	6945	+
	6946	+#ifdef PUGIXML_HAS_MOVE
	6947	+ PUGI__FN xml_document::xml_document(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT: _buffer(0)
	6948	+ {
	6949	+ _create();
	6950	+ _move(rhs);
	6951	+ }
	6952	+
	6953	+ PUGI__FN xml_document& xml_document::operator=(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT
	6954	+ {
	6955	+ if (this == &rhs) return *this;
	6956	+
	6957	+ _destroy();
	6958	+ _create();
	6959	+ _move(rhs);
	6960	+
	6961	+ return *this;
	6962	+ }
	6963	+#endif
	6964	+
	6965	+ PUGI__FN void xml_document::reset()
	6966	+ {
	6967	+ _destroy();
	6968	+ _create();
	6969	+ }
	6970	+
	6971	+ PUGI__FN void xml_document::reset(const xml_document& proto)
	6972	+ {
	6973	+ reset();
	6974	+
	6975	+ impl::node_copy_tree(_root, proto._root);
	6976	+ }
	6977	+
	6978	+ PUGI__FN void xml_document::_create()
	6979	+ {
	6980	+ assert(!_root);
	6981	+
	6982	+ #ifdef PUGIXML_COMPACT
	6983	+ // space for page marker for the first page (uint32_t), rounded up to pointer size; assumes pointers are at least 32-bit
	6984	+ const size_t page_offset = sizeof(void*);
	6985	+ #else
	6986	+ const size_t page_offset = 0;
	6987	+ #endif
	6988	+
	6989	+ // initialize sentinel page
	6990	+ PUGI__STATIC_ASSERT(sizeof(impl::xml_memory_page) + sizeof(impl::xml_document_struct) + page_offset <= sizeof(_memory));
	6991	+
	6992	+ // prepare page structure
	6993	+ impl::xml_memory_page* page = impl::xml_memory_page::construct(_memory);
	6994	+ assert(page);
	6995	+
	6996	+ page->busy_size = impl::xml_memory_page_size;
	6997	+
	6998	+ // setup first page marker
	6999	+ #ifdef PUGIXML_COMPACT
	7000	+ // round-trip through void* to avoid 'cast increases required alignment of target type' warning
	7001	+ page->compact_page_marker = reinterpret_cast<uint32_t>(static_cast<void>(reinterpret_cast<char*>(page) + sizeof(impl::xml_memory_page)));
	7002	+ *page->compact_page_marker = sizeof(impl::xml_memory_page);
	7003	+ #endif
	7004	+
	7005	+ // allocate new root
	7006	+ _root = new (reinterpret_cast<char*>(page) + sizeof(impl::xml_memory_page) + page_offset) impl::xml_document_struct(page);
	7007	+ _root->prev_sibling_c = _root;
	7008	+
	7009	+ // setup sentinel page
	7010	+ page->allocator = static_cast<impl::xml_document_struct*>(_root);
	7011	+
	7012	+ // setup hash table pointer in allocator
	7013	+ #ifdef PUGIXML_COMPACT
	7014	+ page->allocator->_hash = &static_cast<impl::xml_document_struct*>(_root)->hash;
	7015	+ #endif
	7016	+
	7017	+ // verify the document allocation
	7018	+ assert(reinterpret_cast<char*>(_root) + sizeof(impl::xml_document_struct) <= _memory + sizeof(_memory));
	7019	+ }
	7020	+
	7021	+ PUGI__FN void xml_document::_destroy()
	7022	+ {
	7023	+ assert(_root);
	7024	+
	7025	+ // destroy static storage
	7026	+ if (_buffer)
	7027	+ {
	7028	+ impl::xml_memory::deallocate(_buffer);
	7029	+ _buffer = 0;
	7030	+ }
	7031	+
	7032	+ // destroy extra buffers (note: no need to destroy linked list nodes, they're allocated using document allocator)
	7033	+ for (impl::xml_extra_buffer* extra = static_cast<impl::xml_document_struct*>(_root)->extra_buffers; extra; extra = extra->next)
	7034	+ {
	7035	+ if (extra->buffer) impl::xml_memory::deallocate(extra->buffer);
	7036	+ }
	7037	+
	7038	+ // destroy dynamic storage, leave sentinel page (it's in static memory)
	7039	+ impl::xml_memory_page* root_page = PUGI__GETPAGE(_root);
	7040	+ assert(root_page && !root_page->prev);
	7041	+ assert(reinterpret_cast<char>(root_page) >= _memory && reinterpret_cast<char>(root_page) < _memory + sizeof(_memory));
	7042	+
	7043	+ for (impl::xml_memory_page* page = root_page->next; page; )
	7044	+ {
	7045	+ impl::xml_memory_page* next = page->next;
	7046	+
	7047	+ impl::xml_allocator::deallocate_page(page);
	7048	+
	7049	+ page = next;
	7050	+ }
	7051	+
	7052	+ #ifdef PUGIXML_COMPACT
	7053	+ // destroy hash table
	7054	+ static_cast<impl::xml_document_struct*>(_root)->hash.clear();
	7055	+ #endif
	7056	+
	7057	+ _root = 0;
	7058	+ }
	7059	+
	7060	+#ifdef PUGIXML_HAS_MOVE
	7061	+ PUGI__FN void xml_document::_move(xml_document& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT
	7062	+ {
	7063	+ impl::xml_document_struct* doc = static_cast<impl::xml_document_struct*>(_root);
	7064	+ impl::xml_document_struct* other = static_cast<impl::xml_document_struct*>(rhs._root);
	7065	+
	7066	+ // save first child pointer for later; this needs hash access
	7067	+ xml_node_struct* other_first_child = other->first_child;
	7068	+
	7069	+ #ifdef PUGIXML_COMPACT
	7070	+ // reserve space for the hash table up front; this is the only operation that can fail
	7071	+ // if it does, we have no choice but to throw (if we have exceptions)
	7072	+ if (other_first_child)
	7073	+ {
	7074	+ size_t other_children = 0;
	7075	+ for (xml_node_struct* node = other_first_child; node; node = node->next_sibling)
	7076	+ other_children++;
	7077	+
	7078	+ // in compact mode, each pointer assignment could result in a hash table request
	7079	+ // during move, we have to relocate document first_child and parents of all children
	7080	+ // normally there's just one child and its parent has a pointerless encoding but
	7081	+ // we assume the worst here
	7082	+ if (!other->_hash->reserve(other_children + 1))
	7083	+ {
	7084	+ #ifdef PUGIXML_NO_EXCEPTIONS
	7085	+ return;
	7086	+ #else
	7087	+ throw std::bad_alloc();
	7088	+ #endif
	7089	+ }
	7090	+ }
	7091	+ #endif
	7092	+
	7093	+ // move allocation state
	7094	+ doc->_root = other->_root;
	7095	+ doc->_busy_size = other->_busy_size;
	7096	+
	7097	+ // move buffer state
	7098	+ doc->buffer = other->buffer;
	7099	+ doc->extra_buffers = other->extra_buffers;
	7100	+ _buffer = rhs._buffer;
	7101	+
	7102	+ #ifdef PUGIXML_COMPACT
	7103	+ // move compact hash; note that the hash table can have pointers to other but they will be "inactive", similarly to nodes removed with remove_child
	7104	+ doc->hash = other->hash;
	7105	+ doc->_hash = &doc->hash;
	7106	+
	7107	+ // make sure we don't access other hash up until the end when we reinitialize other document
	7108	+ other->_hash = 0;
	7109	+ #endif
	7110	+
	7111	+ // move page structure
	7112	+ impl::xml_memory_page* doc_page = PUGI__GETPAGE(doc);
	7113	+ assert(doc_page && !doc_page->prev && !doc_page->next);
	7114	+
	7115	+ impl::xml_memory_page* other_page = PUGI__GETPAGE(other);
	7116	+ assert(other_page && !other_page->prev);
	7117	+
	7118	+ // relink pages since root page is embedded into xml_document
	7119	+ if (impl::xml_memory_page* page = other_page->next)
	7120	+ {
	7121	+ assert(page->prev == other_page);
	7122	+
	7123	+ page->prev = doc_page;
	7124	+
	7125	+ doc_page->next = page;
	7126	+ other_page->next = 0;
	7127	+ }
	7128	+
	7129	+ // make sure pages point to the correct document state
	7130	+ for (impl::xml_memory_page* page = doc_page->next; page; page = page->next)
	7131	+ {
	7132	+ assert(page->allocator == other);
	7133	+
	7134	+ page->allocator = doc;
	7135	+
	7136	+ #ifdef PUGIXML_COMPACT
	7137	+ // this automatically migrates most children between documents and prevents ->parent assignment from allocating
	7138	+ if (page->compact_shared_parent == other)
	7139	+ page->compact_shared_parent = doc;
	7140	+ #endif
	7141	+ }
	7142	+
	7143	+ // move tree structure
	7144	+ assert(!doc->first_child);
	7145	+
	7146	+ doc->first_child = other_first_child;
	7147	+
	7148	+ for (xml_node_struct* node = other_first_child; node; node = node->next_sibling)
	7149	+ {
	7150	+ #ifdef PUGIXML_COMPACT
	7151	+ // most children will have migrated when we reassigned compact_shared_parent
	7152	+ assert(node->parent == other \|\| node->parent == doc);
	7153	+
	7154	+ node->parent = doc;
	7155	+ #else
	7156	+ assert(node->parent == other);
	7157	+ node->parent = doc;
	7158	+ #endif
	7159	+ }
	7160	+
	7161	+ // reset other document
	7162	+ new (other) impl::xml_document_struct(PUGI__GETPAGE(other));
	7163	+ rhs._buffer = 0;
	7164	+ }
	7165	+#endif
	7166	+
	7167	+#ifndef PUGIXML_NO_STL
	7168	+ PUGI__FN xml_parse_result xml_document::load(std::basic_istream<char, std::char_traits<char> >& stream, unsigned int options, xml_encoding encoding)
	7169	+ {
	7170	+ reset();
	7171	+
	7172	+ return impl::load_stream_impl(static_cast<impl::xml_document_struct*>(_root), stream, options, encoding, &_buffer);
	7173	+ }
	7174	+
	7175	+ PUGI__FN xml_parse_result xml_document::load(std::basic_istream<wchar_t, std::char_traits<wchar_t> >& stream, unsigned int options)
	7176	+ {
	7177	+ reset();
	7178	+
	7179	+ return impl::load_stream_impl(static_cast<impl::xml_document_struct*>(_root), stream, options, encoding_wchar, &_buffer);
	7180	+ }
	7181	+#endif
	7182	+
	7183	+ PUGI__FN xml_parse_result xml_document::load_string(const char_t* contents, unsigned int options)
	7184	+ {
	7185	+ // Force native encoding (skip autodetection)
	7186	+ #ifdef PUGIXML_WCHAR_MODE
	7187	+ xml_encoding encoding = encoding_wchar;
	7188	+ #else
	7189	+ xml_encoding encoding = encoding_utf8;
	7190	+ #endif
	7191	+
	7192	+ return load_buffer(contents, impl::strlength(contents) * sizeof(char_t), options, encoding);
	7193	+ }
	7194	+
	7195	+ PUGI__FN xml_parse_result xml_document::load(const char_t* contents, unsigned int options)
	7196	+ {
	7197	+ return load_string(contents, options);
	7198	+ }
	7199	+
	7200	+ PUGI__FN xml_parse_result xml_document::load_file(const char* path_, unsigned int options, xml_encoding encoding)
	7201	+ {
	7202	+ reset();
	7203	+
	7204	+ using impl::auto_deleter; // MSVC7 workaround
	7205	+ auto_deleter<FILE> file(impl::open_file(path_, "rb"), impl::close_file);
	7206	+
	7207	+ return impl::load_file_impl(static_cast<impl::xml_document_struct*>(_root), file.data, options, encoding, &_buffer);
	7208	+ }
	7209	+
	7210	+ PUGI__FN xml_parse_result xml_document::load_file(const wchar_t* path_, unsigned int options, xml_encoding encoding)
	7211	+ {
	7212	+ reset();
	7213	+
	7214	+ using impl::auto_deleter; // MSVC7 workaround
	7215	+ auto_deleter<FILE> file(impl::open_file_wide(path_, L"rb"), impl::close_file);
	7216	+
	7217	+ return impl::load_file_impl(static_cast<impl::xml_document_struct*>(_root), file.data, options, encoding, &_buffer);
	7218	+ }
	7219	+
	7220	+ PUGI__FN xml_parse_result xml_document::load_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding)
	7221	+ {
	7222	+ reset();
	7223	+
	7224	+ return impl::load_buffer_impl(static_cast<impl::xml_document_struct>(_root), _root, const_cast<void>(contents), size, options, encoding, false, false, &_buffer);
	7225	+ }
	7226	+
	7227	+ PUGI__FN xml_parse_result xml_document::load_buffer_inplace(void* contents, size_t size, unsigned int options, xml_encoding encoding)
	7228	+ {
	7229	+ reset();
	7230	+
	7231	+ return impl::load_buffer_impl(static_cast<impl::xml_document_struct*>(_root), _root, contents, size, options, encoding, true, false, &_buffer);
	7232	+ }
	7233	+
	7234	+ PUGI__FN xml_parse_result xml_document::load_buffer_inplace_own(void* contents, size_t size, unsigned int options, xml_encoding encoding)
	7235	+ {
	7236	+ reset();
	7237	+
	7238	+ return impl::load_buffer_impl(static_cast<impl::xml_document_struct*>(_root), _root, contents, size, options, encoding, true, true, &_buffer);
	7239	+ }
	7240	+
	7241	+ PUGI__FN void xml_document::save(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding) const
	7242	+ {
	7243	+ impl::xml_buffered_writer buffered_writer(writer, encoding);
	7244	+
	7245	+ if ((flags & format_write_bom) && encoding != encoding_latin1)
	7246	+ {
	7247	+ // BOM always represents the codepoint U+FEFF, so just write it in native encoding
	7248	+ #ifdef PUGIXML_WCHAR_MODE
	7249	+ unsigned int bom = 0xfeff;
	7250	+ buffered_writer.write(static_cast<wchar_t>(bom));
	7251	+ #else
	7252	+ buffered_writer.write('\xef', '\xbb', '\xbf');
	7253	+ #endif
	7254	+ }
	7255	+
	7256	+ if (!(flags & format_no_declaration) && !impl::has_declaration(_root))
	7257	+ {
	7258	+ buffered_writer.write_string(PUGIXML_TEXT("<?xml version=\"1.0\""));
	7259	+ if (encoding == encoding_latin1) buffered_writer.write_string(PUGIXML_TEXT(" encoding=\"ISO-8859-1\""));
	7260	+ buffered_writer.write('?', '>');
	7261	+ if (!(flags & format_raw)) buffered_writer.write('\n');
	7262	+ }
	7263	+
	7264	+ impl::node_output(buffered_writer, _root, indent, flags, 0);
	7265	+
	7266	+ buffered_writer.flush();
	7267	+ }
	7268	+
	7269	+#ifndef PUGIXML_NO_STL
	7270	+ PUGI__FN void xml_document::save(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding) const
	7271	+ {
	7272	+ xml_writer_stream writer(stream);
	7273	+
	7274	+ save(writer, indent, flags, encoding);
	7275	+ }
	7276	+
	7277	+ PUGI__FN void xml_document::save(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent, unsigned int flags) const
	7278	+ {
	7279	+ xml_writer_stream writer(stream);
	7280	+
	7281	+ save(writer, indent, flags, encoding_wchar);
	7282	+ }
	7283	+#endif
	7284	+
	7285	+ PUGI__FN bool xml_document::save_file(const char* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
	7286	+ {
	7287	+ using impl::auto_deleter; // MSVC7 workaround
	7288	+ auto_deleter<FILE> file(impl::open_file(path_, (flags & format_save_file_text) ? "w" : "wb"), impl::close_file);
	7289	+
	7290	+ return impl::save_file_impl(*this, file.data, indent, flags, encoding);
	7291	+ }
	7292	+
	7293	+ PUGI__FN bool xml_document::save_file(const wchar_t* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
	7294	+ {
	7295	+ using impl::auto_deleter; // MSVC7 workaround
	7296	+ auto_deleter<FILE> file(impl::open_file_wide(path_, (flags & format_save_file_text) ? L"w" : L"wb"), impl::close_file);
	7297	+
	7298	+ return impl::save_file_impl(*this, file.data, indent, flags, encoding);
	7299	+ }
	7300	+
	7301	+ PUGI__FN xml_node xml_document::document_element() const
	7302	+ {
	7303	+ assert(_root);
	7304	+
	7305	+ for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
	7306	+ if (PUGI__NODETYPE(i) == node_element)
	7307	+ return xml_node(i);
	7308	+
	7309	+ return xml_node();
	7310	+ }
	7311	+
	7312	+#ifndef PUGIXML_NO_STL
	7313	+ PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const wchar_t* str)
	7314	+ {
	7315	+ assert(str);
	7316	+
	7317	+ return impl::as_utf8_impl(str, impl::strlength_wide(str));
	7318	+ }
	7319	+
	7320	+ PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const std::basic_string<wchar_t>& str)
	7321	+ {
	7322	+ return impl::as_utf8_impl(str.c_str(), str.size());
	7323	+ }
	7324	+
	7325	+ PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const char* str)
	7326	+ {
	7327	+ assert(str);
	7328	+
	7329	+ return impl::as_wide_impl(str, strlen(str));
	7330	+ }
	7331	+
	7332	+ PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const std::string& str)
	7333	+ {
	7334	+ return impl::as_wide_impl(str.c_str(), str.size());
	7335	+ }
	7336	+#endif
	7337	+
	7338	+ PUGI__FN void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate)
	7339	+ {
	7340	+ impl::xml_memory::allocate = allocate;
	7341	+ impl::xml_memory::deallocate = deallocate;
	7342	+ }
	7343	+
	7344	+ PUGI__FN allocation_function PUGIXML_FUNCTION get_memory_allocation_function()
	7345	+ {
	7346	+ return impl::xml_memory::allocate;
	7347	+ }
	7348	+
	7349	+ PUGI__FN deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function()
	7350	+ {
	7351	+ return impl::xml_memory::deallocate;
	7352	+ }
	7353	+}
	7354	+
	7355	+#if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) \|\| defined(__ICC))
	7356	+namespace std
	7357	+{
	7358	+ // Workarounds for (non-standard) iterator category detection for older versions (MSVC7/IC8 and earlier)
	7359	+ PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_node_iterator&)
	7360	+ {
	7361	+ return std::bidirectional_iterator_tag();
	7362	+ }
	7363	+
	7364	+ PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_attribute_iterator&)
	7365	+ {
	7366	+ return std::bidirectional_iterator_tag();
	7367	+ }
	7368	+
	7369	+ PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_named_node_iterator&)
	7370	+ {
	7371	+ return std::bidirectional_iterator_tag();
	7372	+ }
	7373	+}
	7374	+#endif
	7375	+
	7376	+#if !defined(PUGIXML_NO_STL) && defined(__SUNPRO_CC)
	7377	+namespace std
	7378	+{
	7379	+ // Workarounds for (non-standard) iterator category detection
	7380	+ PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_node_iterator&)
	7381	+ {
	7382	+ return std::bidirectional_iterator_tag();
	7383	+ }
	7384	+
	7385	+ PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_attribute_iterator&)
	7386	+ {
	7387	+ return std::bidirectional_iterator_tag();
	7388	+ }
	7389	+
	7390	+ PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_named_node_iterator&)
	7391	+ {
	7392	+ return std::bidirectional_iterator_tag();
	7393	+ }
	7394	+}
	7395	+#endif
	7396	+
	7397	+#ifndef PUGIXML_NO_XPATH
	7398	+// STL replacements
	7399	+PUGI__NS_BEGIN
	7400	+ struct equal_to
	7401	+ {
	7402	+ template <typename T> bool operator()(const T& lhs, const T& rhs) const
	7403	+ {
	7404	+ return lhs == rhs;
	7405	+ }
	7406	+ };
	7407	+
	7408	+ struct not_equal_to
	7409	+ {
	7410	+ template <typename T> bool operator()(const T& lhs, const T& rhs) const
	7411	+ {
	7412	+ return lhs != rhs;
	7413	+ }
	7414	+ };
	7415	+
	7416	+ struct less
	7417	+ {
	7418	+ template <typename T> bool operator()(const T& lhs, const T& rhs) const
	7419	+ {
	7420	+ return lhs < rhs;
	7421	+ }
	7422	+ };
	7423	+
	7424	+ struct less_equal
	7425	+ {
	7426	+ template <typename T> bool operator()(const T& lhs, const T& rhs) const
	7427	+ {
	7428	+ return lhs <= rhs;
	7429	+ }
	7430	+ };
	7431	+
	7432	+ template <typename T> inline void swap(T& lhs, T& rhs)
	7433	+ {
	7434	+ T temp = lhs;
	7435	+ lhs = rhs;
	7436	+ rhs = temp;
	7437	+ }
	7438	+
	7439	+ template <typename I, typename Pred> PUGI__FN I min_element(I begin, I end, const Pred& pred)
	7440	+ {
	7441	+ I result = begin;
	7442	+
	7443	+ for (I it = begin + 1; it != end; ++it)
	7444	+ if (pred(it, result))
	7445	+ result = it;
	7446	+
	7447	+ return result;
	7448	+ }
	7449	+
	7450	+ template <typename I> PUGI__FN void reverse(I begin, I end)
	7451	+ {
	7452	+ while (end - begin > 1)
	7453	+ swap(begin++, --end);
	7454	+ }
	7455	+
	7456	+ template <typename I> PUGI__FN I unique(I begin, I end)
	7457	+ {
	7458	+ // fast skip head
	7459	+ while (end - begin > 1 && begin != (begin + 1))
	7460	+ begin++;
	7461	+
	7462	+ if (begin == end)
	7463	+ return begin;
	7464	+
	7465	+ // last written element
	7466	+ I write = begin++;
	7467	+
	7468	+ // merge unique elements
	7469	+ while (begin != end)
	7470	+ {
	7471	+ if (begin != write)
	7472	+ ++write = begin++;
	7473	+ else
	7474	+ begin++;
	7475	+ }
	7476	+
	7477	+ // past-the-end (write points to live element)
	7478	+ return write + 1;
	7479	+ }
	7480	+
	7481	+ template <typename T, typename Pred> PUGI__FN void insertion_sort(T* begin, T* end, const Pred& pred)
	7482	+ {
	7483	+ if (begin == end)
	7484	+ return;
	7485	+
	7486	+ for (T* it = begin + 1; it != end; ++it)
	7487	+ {
	7488	+ T val = *it;
	7489	+ T* hole = it;
	7490	+
	7491	+ // move hole backwards
	7492	+ while (hole > begin && pred(val, *(hole - 1)))
	7493	+ {
	7494	+ hole = (hole - 1);
	7495	+ hole--;
	7496	+ }
	7497	+
	7498	+ // fill hole with element
	7499	+ *hole = val;
	7500	+ }
	7501	+ }
	7502	+
	7503	+ template <typename I, typename Pred> inline I median3(I first, I middle, I last, const Pred& pred)
	7504	+ {
	7505	+ if (pred(middle, first))
	7506	+ swap(middle, first);
	7507	+ if (pred(last, middle))
	7508	+ swap(last, middle);
	7509	+ if (pred(middle, first))
	7510	+ swap(middle, first);
	7511	+
	7512	+ return middle;
	7513	+ }
	7514	+
	7515	+ template <typename T, typename Pred> PUGI__FN void partition3(T* begin, T* end, T pivot, const Pred& pred, T out_eqbeg, T out_eqend)
	7516	+ {
	7517	+ // invariant: array is split into 4 groups: = < ? > (each variable denotes the boundary between the groups)
	7518	+ T* eq = begin;
	7519	+ T* lt = begin;
	7520	+ T* gt = end;
	7521	+
	7522	+ while (lt < gt)
	7523	+ {
	7524	+ if (pred(*lt, pivot))
	7525	+ lt++;
	7526	+ else if (*lt == pivot)
	7527	+ swap(eq++, lt++);
	7528	+ else
	7529	+ swap(lt, --gt);
	7530	+ }
	7531	+
	7532	+ // we now have just 4 groups: = < >; move equal elements to the middle
	7533	+ T* eqbeg = gt;
	7534	+
	7535	+ for (T* it = begin; it != eq; ++it)
	7536	+ swap(it, --eqbeg);
	7537	+
	7538	+ *out_eqbeg = eqbeg;
	7539	+ *out_eqend = gt;
	7540	+ }
	7541	+
	7542	+ template <typename I, typename Pred> PUGI__FN void sort(I begin, I end, const Pred& pred)
	7543	+ {
	7544	+ // sort large chunks
	7545	+ while (end - begin > 16)
	7546	+ {
	7547	+ // find median element
	7548	+ I middle = begin + (end - begin) / 2;
	7549	+ I median = median3(begin, middle, end - 1, pred);
	7550	+
	7551	+ // partition in three chunks (< = >)
	7552	+ I eqbeg, eqend;
	7553	+ partition3(begin, end, *median, pred, &eqbeg, &eqend);
	7554	+
	7555	+ // loop on larger half
	7556	+ if (eqbeg - begin > end - eqend)
	7557	+ {
	7558	+ sort(eqend, end, pred);
	7559	+ end = eqbeg;
	7560	+ }
	7561	+ else
	7562	+ {
	7563	+ sort(begin, eqbeg, pred);
	7564	+ begin = eqend;
	7565	+ }
	7566	+ }
	7567	+
	7568	+ // insertion sort small chunk
	7569	+ insertion_sort(begin, end, pred);
	7570	+ }
	7571	+
	7572	+ PUGI__FN bool hash_insert(const void** table, size_t size, const void* key)
	7573	+ {
	7574	+ assert(key);
	7575	+
	7576	+ unsigned int h = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(key));
	7577	+
	7578	+ // MurmurHash3 32-bit finalizer
	7579	+ h ^= h >> 16;
	7580	+ h *= 0x85ebca6bu;
	7581	+ h ^= h >> 13;
	7582	+ h *= 0xc2b2ae35u;
	7583	+ h ^= h >> 16;
	7584	+
	7585	+ size_t hashmod = size - 1;
	7586	+ size_t bucket = h & hashmod;
	7587	+
	7588	+ for (size_t probe = 0; probe <= hashmod; ++probe)
	7589	+ {
	7590	+ if (table[bucket] == 0)
	7591	+ {
	7592	+ table[bucket] = key;
	7593	+ return true;
	7594	+ }
	7595	+
	7596	+ if (table[bucket] == key)
	7597	+ return false;
	7598	+
	7599	+ // hash collision, quadratic probing
	7600	+ bucket = (bucket + probe + 1) & hashmod;
	7601	+ }
	7602	+
	7603	+ assert(false && "Hash table is full"); // unreachable
	7604	+ return false;
	7605	+ }
	7606	+PUGI__NS_END
	7607	+
	7608	+// Allocator used for AST and evaluation stacks
	7609	+PUGI__NS_BEGIN
	7610	+ static const size_t xpath_memory_page_size =
	7611	+ #ifdef PUGIXML_MEMORY_XPATH_PAGE_SIZE
	7612	+ PUGIXML_MEMORY_XPATH_PAGE_SIZE
	7613	+ #else
	7614	+ 4096
	7615	+ #endif
	7616	+ ;
	7617	+
	7618	+ static const uintptr_t xpath_memory_block_alignment = sizeof(double) > sizeof(void) ? sizeof(double) : sizeof(void);
	7619	+
	7620	+ struct xpath_memory_block
	7621	+ {
	7622	+ xpath_memory_block* next;
	7623	+ size_t capacity;
	7624	+
	7625	+ union
	7626	+ {
	7627	+ char data[xpath_memory_page_size];
	7628	+ double alignment;
	7629	+ };
	7630	+ };
	7631	+
	7632	+ struct xpath_allocator
	7633	+ {
	7634	+ xpath_memory_block* _root;
	7635	+ size_t _root_size;
	7636	+ bool* _error;
	7637	+
	7638	+ xpath_allocator(xpath_memory_block* root, bool* error = 0): _root(root), _root_size(0), _error(error)
	7639	+ {
	7640	+ }
	7641	+
	7642	+ void* allocate(size_t size)
	7643	+ {
	7644	+ // round size up to block alignment boundary
	7645	+ size = (size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);
	7646	+
	7647	+ if (_root_size + size <= _root->capacity)
	7648	+ {
	7649	+ void* buf = &_root->data[0] + _root_size;
	7650	+ _root_size += size;
	7651	+ return buf;
	7652	+ }
	7653	+ else
	7654	+ {
	7655	+ // make sure we have at least 1/4th of the page free after allocation to satisfy subsequent allocation requests
	7656	+ size_t block_capacity_base = sizeof(_root->data);
	7657	+ size_t block_capacity_req = size + block_capacity_base / 4;
	7658	+ size_t block_capacity = (block_capacity_base > block_capacity_req) ? block_capacity_base : block_capacity_req;
	7659	+
	7660	+ size_t block_size = block_capacity + offsetof(xpath_memory_block, data);
	7661	+
	7662	+ xpath_memory_block* block = static_cast<xpath_memory_block*>(xml_memory::allocate(block_size));
	7663	+ if (!block)
	7664	+ {
	7665	+ if (_error) *_error = true;
	7666	+ return 0;
	7667	+ }
	7668	+
	7669	+ block->next = _root;
	7670	+ block->capacity = block_capacity;
	7671	+
	7672	+ _root = block;
	7673	+ _root_size = size;
	7674	+
	7675	+ return block->data;
	7676	+ }
	7677	+ }
	7678	+
	7679	+ void* reallocate(void* ptr, size_t old_size, size_t new_size)
	7680	+ {
	7681	+ // round size up to block alignment boundary
	7682	+ old_size = (old_size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);
	7683	+ new_size = (new_size + xpath_memory_block_alignment - 1) & ~(xpath_memory_block_alignment - 1);
	7684	+
	7685	+ // we can only reallocate the last object
	7686	+ assert(ptr == 0 \|\| static_cast<char*>(ptr) + old_size == &_root->data[0] + _root_size);
	7687	+
	7688	+ // try to reallocate the object inplace
	7689	+ if (ptr && _root_size - old_size + new_size <= _root->capacity)
	7690	+ {
	7691	+ _root_size = _root_size - old_size + new_size;
	7692	+ return ptr;
	7693	+ }
	7694	+
	7695	+ // allocate a new block
	7696	+ void* result = allocate(new_size);
	7697	+ if (!result) return 0;
	7698	+
	7699	+ // we have a new block
	7700	+ if (ptr)
	7701	+ {
	7702	+ // copy old data (we only support growing)
	7703	+ assert(new_size >= old_size);
	7704	+ memcpy(result, ptr, old_size);
	7705	+
	7706	+ // free the previous page if it had no other objects
	7707	+ assert(_root->data == result);
	7708	+ assert(_root->next);
	7709	+
	7710	+ if (_root->next->data == ptr)
	7711	+ {
	7712	+ // deallocate the whole page, unless it was the first one
	7713	+ xpath_memory_block* next = _root->next->next;
	7714	+
	7715	+ if (next)
	7716	+ {
	7717	+ xml_memory::deallocate(_root->next);
	7718	+ _root->next = next;
	7719	+ }
	7720	+ }
	7721	+ }
	7722	+
	7723	+ return result;
	7724	+ }
	7725	+
	7726	+ void revert(const xpath_allocator& state)
	7727	+ {
	7728	+ // free all new pages
	7729	+ xpath_memory_block* cur = _root;
	7730	+
	7731	+ while (cur != state._root)
	7732	+ {
	7733	+ xpath_memory_block* next = cur->next;
	7734	+
	7735	+ xml_memory::deallocate(cur);
	7736	+
	7737	+ cur = next;
	7738	+ }
	7739	+
	7740	+ // restore state
	7741	+ _root = state._root;
	7742	+ _root_size = state._root_size;
	7743	+ }
	7744	+
	7745	+ void release()
	7746	+ {
	7747	+ xpath_memory_block* cur = _root;
	7748	+ assert(cur);
	7749	+
	7750	+ while (cur->next)
	7751	+ {
	7752	+ xpath_memory_block* next = cur->next;
	7753	+
	7754	+ xml_memory::deallocate(cur);
	7755	+
	7756	+ cur = next;
	7757	+ }
	7758	+ }
	7759	+ };
	7760	+
	7761	+ struct xpath_allocator_capture
	7762	+ {
	7763	+ xpath_allocator_capture(xpath_allocator* alloc): _target(alloc), _state(*alloc)
	7764	+ {
	7765	+ }
	7766	+
	7767	+ ~xpath_allocator_capture()
	7768	+ {
	7769	+ _target->revert(_state);
	7770	+ }
	7771	+
	7772	+ xpath_allocator* _target;
	7773	+ xpath_allocator _state;
	7774	+ };
	7775	+
	7776	+ struct xpath_stack
	7777	+ {
	7778	+ xpath_allocator* result;
	7779	+ xpath_allocator* temp;
	7780	+ };
	7781	+
	7782	+ struct xpath_stack_data
	7783	+ {
	7784	+ xpath_memory_block blocks[2];
	7785	+ xpath_allocator result;
	7786	+ xpath_allocator temp;
	7787	+ xpath_stack stack;
	7788	+ bool oom;
	7789	+
	7790	+ xpath_stack_data(): result(blocks + 0, &oom), temp(blocks + 1, &oom), oom(false)
	7791	+ {
	7792	+ blocks[0].next = blocks[1].next = 0;
	7793	+ blocks[0].capacity = blocks[1].capacity = sizeof(blocks[0].data);
	7794	+
	7795	+ stack.result = &result;
	7796	+ stack.temp = &temp;
	7797	+ }
	7798	+
	7799	+ ~xpath_stack_data()
	7800	+ {
	7801	+ result.release();
	7802	+ temp.release();
	7803	+ }
	7804	+ };
	7805	+PUGI__NS_END
	7806	+
	7807	+// String class
	7808	+PUGI__NS_BEGIN
	7809	+ class xpath_string
	7810	+ {
	7811	+ const char_t* _buffer;
	7812	+ bool _uses_heap;
	7813	+ size_t _length_heap;
	7814	+
	7815	+ static char_t* duplicate_string(const char_t* string, size_t length, xpath_allocator* alloc)
	7816	+ {
	7817	+ char_t* result = static_cast<char_t>(alloc->allocate((length + 1) sizeof(char_t)));
	7818	+ if (!result) return 0;
	7819	+
	7820	+ memcpy(result, string, length * sizeof(char_t));
	7821	+ result[length] = 0;
	7822	+
	7823	+ return result;
	7824	+ }
	7825	+
	7826	+ xpath_string(const char_t* buffer, bool uses_heap_, size_t length_heap): _buffer(buffer), _uses_heap(uses_heap_), _length_heap(length_heap)
	7827	+ {
	7828	+ }
	7829	+
	7830	+ public:
	7831	+ static xpath_string from_const(const char_t* str)
	7832	+ {
	7833	+ return xpath_string(str, false, 0);
	7834	+ }
	7835	+
	7836	+ static xpath_string from_heap_preallocated(const char_t* begin, const char_t* end)
	7837	+ {
	7838	+ assert(begin <= end && *end == 0);
	7839	+
	7840	+ return xpath_string(begin, true, static_cast<size_t>(end - begin));
	7841	+ }
	7842	+
	7843	+ static xpath_string from_heap(const char_t* begin, const char_t* end, xpath_allocator* alloc)
	7844	+ {
	7845	+ assert(begin <= end);
	7846	+
	7847	+ if (begin == end)
	7848	+ return xpath_string();
	7849	+
	7850	+ size_t length = static_cast<size_t>(end - begin);
	7851	+ const char_t* data = duplicate_string(begin, length, alloc);
	7852	+
	7853	+ return data ? xpath_string(data, true, length) : xpath_string();
	7854	+ }
	7855	+
	7856	+ xpath_string(): _buffer(PUGIXML_TEXT("")), _uses_heap(false), _length_heap(0)
	7857	+ {
	7858	+ }
	7859	+
	7860	+ void append(const xpath_string& o, xpath_allocator* alloc)
	7861	+ {
	7862	+ // skip empty sources
	7863	+ if (!*o._buffer) return;
	7864	+
	7865	+ // fast append for constant empty target and constant source
	7866	+ if (!*_buffer && !_uses_heap && !o._uses_heap)
	7867	+ {
	7868	+ _buffer = o._buffer;
	7869	+ }
	7870	+ else
	7871	+ {
	7872	+ // need to make heap copy
	7873	+ size_t target_length = length();
	7874	+ size_t source_length = o.length();
	7875	+ size_t result_length = target_length + source_length;
	7876	+
	7877	+ // allocate new buffer
	7878	+ char_t* result = static_cast<char_t>(alloc->reallocate(_uses_heap ? const_cast<char_t>(_buffer) : 0, (target_length + 1) * sizeof(char_t), (result_length + 1) * sizeof(char_t)));
	7879	+ if (!result) return;
	7880	+
	7881	+ // append first string to the new buffer in case there was no reallocation
	7882	+ if (!_uses_heap) memcpy(result, _buffer, target_length * sizeof(char_t));
	7883	+
	7884	+ // append second string to the new buffer
	7885	+ memcpy(result + target_length, o._buffer, source_length * sizeof(char_t));
	7886	+ result[result_length] = 0;
	7887	+
	7888	+ // finalize
	7889	+ _buffer = result;
	7890	+ _uses_heap = true;
	7891	+ _length_heap = result_length;
	7892	+ }
	7893	+ }
	7894	+
	7895	+ const char_t* c_str() const
	7896	+ {
	7897	+ return _buffer;
	7898	+ }
	7899	+
	7900	+ size_t length() const
	7901	+ {
	7902	+ return _uses_heap ? _length_heap : strlength(_buffer);
	7903	+ }
	7904	+
	7905	+ char_t* data(xpath_allocator* alloc)
	7906	+ {
	7907	+ // make private heap copy
	7908	+ if (!_uses_heap)
	7909	+ {
	7910	+ size_t length_ = strlength(_buffer);
	7911	+ const char_t* data_ = duplicate_string(_buffer, length_, alloc);
	7912	+
	7913	+ if (!data_) return 0;
	7914	+
	7915	+ _buffer = data_;
	7916	+ _uses_heap = true;
	7917	+ _length_heap = length_;
	7918	+ }
	7919	+
	7920	+ return const_cast<char_t*>(_buffer);
	7921	+ }
	7922	+
	7923	+ bool empty() const
	7924	+ {
	7925	+ return *_buffer == 0;
	7926	+ }
	7927	+
	7928	+ bool operator==(const xpath_string& o) const
	7929	+ {
	7930	+ return strequal(_buffer, o._buffer);
	7931	+ }
	7932	+
	7933	+ bool operator!=(const xpath_string& o) const
	7934	+ {
	7935	+ return !strequal(_buffer, o._buffer);
	7936	+ }
	7937	+
	7938	+ bool uses_heap() const
	7939	+ {
	7940	+ return _uses_heap;
	7941	+ }
	7942	+ };
	7943	+PUGI__NS_END
	7944	+
	7945	+PUGI__NS_BEGIN
	7946	+ PUGI__FN bool starts_with(const char_t* string, const char_t* pattern)
	7947	+ {
	7948	+ while (pattern && string == *pattern)
	7949	+ {
	7950	+ string++;
	7951	+ pattern++;
	7952	+ }
	7953	+
	7954	+ return *pattern == 0;
	7955	+ }
	7956	+
	7957	+ PUGI__FN const char_t* find_char(const char_t* s, char_t c)
	7958	+ {
	7959	+ #ifdef PUGIXML_WCHAR_MODE
	7960	+ return wcschr(s, c);
	7961	+ #else
	7962	+ return strchr(s, c);
	7963	+ #endif
	7964	+ }
	7965	+
	7966	+ PUGI__FN const char_t* find_substring(const char_t* s, const char_t* p)
	7967	+ {
	7968	+ #ifdef PUGIXML_WCHAR_MODE
	7969	+ // MSVC6 wcsstr bug workaround (if s is empty it always returns 0)
	7970	+ return (*p == 0) ? s : wcsstr(s, p);
	7971	+ #else
	7972	+ return strstr(s, p);
	7973	+ #endif
	7974	+ }
	7975	+
	7976	+ // Converts symbol to lower case, if it is an ASCII one
	7977	+ PUGI__FN char_t tolower_ascii(char_t ch)
	7978	+ {
	7979	+ return static_cast<unsigned int>(ch - 'A') < 26 ? static_cast<char_t>(ch \| ' ') : ch;
	7980	+ }
	7981	+
	7982	+ PUGI__FN xpath_string string_value(const xpath_node& na, xpath_allocator* alloc)
	7983	+ {
	7984	+ if (na.attribute())
	7985	+ return xpath_string::from_const(na.attribute().value());
	7986	+ else
	7987	+ {
	7988	+ xml_node n = na.node();
	7989	+
	7990	+ switch (n.type())
	7991	+ {
	7992	+ case node_pcdata:
	7993	+ case node_cdata:
	7994	+ case node_comment:
	7995	+ case node_pi:
	7996	+ return xpath_string::from_const(n.value());
	7997	+
	7998	+ case node_document:
	7999	+ case node_element:
	8000	+ {
	8001	+ xpath_string result;
	8002	+
	8003	+ // element nodes can have value if parse_embed_pcdata was used
	8004	+ if (n.value()[0])
	8005	+ result.append(xpath_string::from_const(n.value()), alloc);
	8006	+
	8007	+ xml_node cur = n.first_child();
	8008	+
	8009	+ while (cur && cur != n)
	8010	+ {
	8011	+ if (cur.type() == node_pcdata \|\| cur.type() == node_cdata)
	8012	+ result.append(xpath_string::from_const(cur.value()), alloc);
	8013	+
	8014	+ if (cur.first_child())
	8015	+ cur = cur.first_child();
	8016	+ else if (cur.next_sibling())
	8017	+ cur = cur.next_sibling();
	8018	+ else
	8019	+ {
	8020	+ while (!cur.next_sibling() && cur != n)
	8021	+ cur = cur.parent();
	8022	+
	8023	+ if (cur != n) cur = cur.next_sibling();
	8024	+ }
	8025	+ }
	8026	+
	8027	+ return result;
	8028	+ }
	8029	+
	8030	+ default:
	8031	+ return xpath_string();
	8032	+ }
	8033	+ }
	8034	+ }
	8035	+
	8036	+ PUGI__FN bool node_is_before_sibling(xml_node_struct* ln, xml_node_struct* rn)
	8037	+ {
	8038	+ assert(ln->parent == rn->parent);
	8039	+
	8040	+ // there is no common ancestor (the shared parent is null), nodes are from different documents
	8041	+ if (!ln->parent) return ln < rn;
	8042	+
	8043	+ // determine sibling order
	8044	+ xml_node_struct* ls = ln;
	8045	+ xml_node_struct* rs = rn;
	8046	+
	8047	+ while (ls && rs)
	8048	+ {
	8049	+ if (ls == rn) return true;
	8050	+ if (rs == ln) return false;
	8051	+
	8052	+ ls = ls->next_sibling;
	8053	+ rs = rs->next_sibling;
	8054	+ }
	8055	+
	8056	+ // if rn sibling chain ended ln must be before rn
	8057	+ return !rs;
	8058	+ }
	8059	+
	8060	+ PUGI__FN bool node_is_before(xml_node_struct* ln, xml_node_struct* rn)
	8061	+ {
	8062	+ // find common ancestor at the same depth, if any
	8063	+ xml_node_struct* lp = ln;
	8064	+ xml_node_struct* rp = rn;
	8065	+
	8066	+ while (lp && rp && lp->parent != rp->parent)
	8067	+ {
	8068	+ lp = lp->parent;
	8069	+ rp = rp->parent;
	8070	+ }
	8071	+
	8072	+ // parents are the same!
	8073	+ if (lp && rp) return node_is_before_sibling(lp, rp);
	8074	+
	8075	+ // nodes are at different depths, need to normalize heights
	8076	+ bool left_higher = !lp;
	8077	+
	8078	+ while (lp)
	8079	+ {
	8080	+ lp = lp->parent;
	8081	+ ln = ln->parent;
	8082	+ }
	8083	+
	8084	+ while (rp)
	8085	+ {
	8086	+ rp = rp->parent;
	8087	+ rn = rn->parent;
	8088	+ }
	8089	+
	8090	+ // one node is the ancestor of the other
	8091	+ if (ln == rn) return left_higher;
	8092	+
	8093	+ // find common ancestor... again
	8094	+ while (ln->parent != rn->parent)
	8095	+ {
	8096	+ ln = ln->parent;
	8097	+ rn = rn->parent;
	8098	+ }
	8099	+
	8100	+ return node_is_before_sibling(ln, rn);
	8101	+ }
	8102	+
	8103	+ PUGI__FN bool node_is_ancestor(xml_node_struct* parent, xml_node_struct* node)
	8104	+ {
	8105	+ while (node && node != parent) node = node->parent;
	8106	+
	8107	+ return parent && node == parent;
	8108	+ }
	8109	+
	8110	+ PUGI__FN const void* document_buffer_order(const xpath_node& xnode)
	8111	+ {
	8112	+ xml_node_struct* node = xnode.node().internal_object();
	8113	+
	8114	+ if (node)
	8115	+ {
	8116	+ if ((get_document(node).header & xml_memory_page_contents_shared_mask) == 0)
	8117	+ {
	8118	+ if (node->name && (node->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0) return node->name;
	8119	+ if (node->value && (node->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0) return node->value;
	8120	+ }
	8121	+
	8122	+ return 0;
	8123	+ }
	8124	+
	8125	+ xml_attribute_struct* attr = xnode.attribute().internal_object();
	8126	+
	8127	+ if (attr)
	8128	+ {
	8129	+ if ((get_document(attr).header & xml_memory_page_contents_shared_mask) == 0)
	8130	+ {
	8131	+ if ((attr->header & impl::xml_memory_page_name_allocated_or_shared_mask) == 0) return attr->name;
	8132	+ if ((attr->header & impl::xml_memory_page_value_allocated_or_shared_mask) == 0) return attr->value;
	8133	+ }
	8134	+
	8135	+ return 0;
	8136	+ }
	8137	+
	8138	+ return 0;
	8139	+ }
	8140	+
	8141	+ struct document_order_comparator
	8142	+ {
	8143	+ bool operator()(const xpath_node& lhs, const xpath_node& rhs) const
	8144	+ {
	8145	+ // optimized document order based check
	8146	+ const void* lo = document_buffer_order(lhs);
	8147	+ const void* ro = document_buffer_order(rhs);
	8148	+
	8149	+ if (lo && ro) return lo < ro;
	8150	+
	8151	+ // slow comparison
	8152	+ xml_node ln = lhs.node(), rn = rhs.node();
	8153	+
	8154	+ // compare attributes
	8155	+ if (lhs.attribute() && rhs.attribute())
	8156	+ {
	8157	+ // shared parent
	8158	+ if (lhs.parent() == rhs.parent())
	8159	+ {
	8160	+ // determine sibling order
	8161	+ for (xml_attribute a = lhs.attribute(); a; a = a.next_attribute())
	8162	+ if (a == rhs.attribute())
	8163	+ return true;
	8164	+
	8165	+ return false;
	8166	+ }
	8167	+
	8168	+ // compare attribute parents
	8169	+ ln = lhs.parent();
	8170	+ rn = rhs.parent();
	8171	+ }
	8172	+ else if (lhs.attribute())
	8173	+ {
	8174	+ // attributes go after the parent element
	8175	+ if (lhs.parent() == rhs.node()) return false;
	8176	+
	8177	+ ln = lhs.parent();
	8178	+ }
	8179	+ else if (rhs.attribute())
	8180	+ {
	8181	+ // attributes go after the parent element
	8182	+ if (rhs.parent() == lhs.node()) return true;
	8183	+
	8184	+ rn = rhs.parent();
	8185	+ }
	8186	+
	8187	+ if (ln == rn) return false;
	8188	+
	8189	+ if (!ln \|\| !rn) return ln < rn;
	8190	+
	8191	+ return node_is_before(ln.internal_object(), rn.internal_object());
	8192	+ }
	8193	+ };
	8194	+
	8195	+ PUGI__FN double gen_nan()
	8196	+ {
	8197	+ #if defined(__STDC_IEC_559__) \|\| ((FLT_RADIX - 0 == 2) && (FLT_MAX_EXP - 0 == 128) && (FLT_MANT_DIG - 0 == 24))
	8198	+ PUGI__STATIC_ASSERT(sizeof(float) == sizeof(uint32_t));
	8199	+ typedef uint32_t UI; // BCC5 workaround
	8200	+ union { float f; UI i; } u;
	8201	+ u.i = 0x7fc00000;
	8202	+ return double(u.f);
	8203	+ #else
	8204	+ // fallback
	8205	+ const volatile double zero = 0.0;
	8206	+ return zero / zero;
	8207	+ #endif
	8208	+ }
	8209	+
	8210	+ PUGI__FN bool is_nan(double value)
	8211	+ {
	8212	+ #if defined(PUGI__MSVC_CRT_VERSION) \|\| defined(__BORLANDC__)
	8213	+ return !!_isnan(value);
	8214	+ #elif defined(fpclassify) && defined(FP_NAN)
	8215	+ return fpclassify(value) == FP_NAN;
	8216	+ #else
	8217	+ // fallback
	8218	+ const volatile double v = value;
	8219	+ return v != v;
	8220	+ #endif
	8221	+ }
	8222	+
	8223	+ PUGI__FN const char_t* convert_number_to_string_special(double value)
	8224	+ {
	8225	+ #if defined(PUGI__MSVC_CRT_VERSION) \|\| defined(__BORLANDC__)
	8226	+ if (_finite(value)) return (value == 0) ? PUGIXML_TEXT("0") : 0;
	8227	+ if (_isnan(value)) return PUGIXML_TEXT("NaN");
	8228	+ return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
	8229	+ #elif defined(fpclassify) && defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO)
	8230	+ switch (fpclassify(value))
	8231	+ {
	8232	+ case FP_NAN:
	8233	+ return PUGIXML_TEXT("NaN");
	8234	+
	8235	+ case FP_INFINITE:
	8236	+ return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
	8237	+
	8238	+ case FP_ZERO:
	8239	+ return PUGIXML_TEXT("0");
	8240	+
	8241	+ default:
	8242	+ return 0;
	8243	+ }
	8244	+ #else
	8245	+ // fallback
	8246	+ const volatile double v = value;
	8247	+
	8248	+ if (v == 0) return PUGIXML_TEXT("0");
	8249	+ if (v != v) return PUGIXML_TEXT("NaN");
	8250	+ if (v * 2 == v) return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
	8251	+ return 0;
	8252	+ #endif
	8253	+ }
	8254	+
	8255	+ PUGI__FN bool convert_number_to_boolean(double value)
	8256	+ {
	8257	+ return (value != 0 && !is_nan(value));
	8258	+ }
	8259	+
	8260	+ PUGI__FN void truncate_zeros(char* begin, char* end)
	8261	+ {
	8262	+ while (begin != end && end[-1] == '0') end--;
	8263	+
	8264	+ *end = 0;
	8265	+ }
	8266	+
	8267	+ // gets mantissa digits in the form of 0.xxxxx with 0. implied and the exponent
	8268	+#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE)
	8269	+ PUGI__FN void convert_number_to_mantissa_exponent(double value, char (&buffer)[32], char** out_mantissa, int* out_exponent)
	8270	+ {
	8271	+ // get base values
	8272	+ int sign, exponent;
	8273	+ _ecvt_s(buffer, sizeof(buffer), value, DBL_DIG + 1, &exponent, &sign);
	8274	+
	8275	+ // truncate redundant zeros
	8276	+ truncate_zeros(buffer, buffer + strlen(buffer));
	8277	+
	8278	+ // fill results
	8279	+ *out_mantissa = buffer;
	8280	+ *out_exponent = exponent;
	8281	+ }
	8282	+#else
	8283	+ PUGI__FN void convert_number_to_mantissa_exponent(double value, char (&buffer)[32], char** out_mantissa, int* out_exponent)
	8284	+ {
	8285	+ // get a scientific notation value with IEEE DBL_DIG decimals
	8286	+ PUGI__SNPRINTF(buffer, "%.*e", DBL_DIG, value);
	8287	+
	8288	+ // get the exponent (possibly negative)
	8289	+ char* exponent_string = strchr(buffer, 'e');
	8290	+ assert(exponent_string);
	8291	+
	8292	+ int exponent = atoi(exponent_string + 1);
	8293	+
	8294	+ // extract mantissa string: skip sign
	8295	+ char* mantissa = buffer[0] == '-' ? buffer + 1 : buffer;
	8296	+ assert(mantissa[0] != '0' && mantissa[1] == '.');
	8297	+
	8298	+ // divide mantissa by 10 to eliminate integer part
	8299	+ mantissa[1] = mantissa[0];
	8300	+ mantissa++;
	8301	+ exponent++;
	8302	+
	8303	+ // remove extra mantissa digits and zero-terminate mantissa
	8304	+ truncate_zeros(mantissa, exponent_string);
	8305	+
	8306	+ // fill results
	8307	+ *out_mantissa = mantissa;
	8308	+ *out_exponent = exponent;
	8309	+ }
	8310	+#endif
	8311	+
	8312	+ PUGI__FN xpath_string convert_number_to_string(double value, xpath_allocator* alloc)
	8313	+ {
	8314	+ // try special number conversion
	8315	+ const char_t* special = convert_number_to_string_special(value);
	8316	+ if (special) return xpath_string::from_const(special);
	8317	+
	8318	+ // get mantissa + exponent form
	8319	+ char mantissa_buffer[32];
	8320	+
	8321	+ char* mantissa;
	8322	+ int exponent;
	8323	+ convert_number_to_mantissa_exponent(value, mantissa_buffer, &mantissa, &exponent);
	8324	+
	8325	+ // allocate a buffer of suitable length for the number
	8326	+ size_t result_size = strlen(mantissa_buffer) + (exponent > 0 ? exponent : -exponent) + 4;
	8327	+ char_t* result = static_cast<char_t>(alloc->allocate(sizeof(char_t) result_size));
	8328	+ if (!result) return xpath_string();
	8329	+
	8330	+ // make the number!
	8331	+ char_t* s = result;
	8332	+
	8333	+ // sign
	8334	+ if (value < 0) *s++ = '-';
	8335	+
	8336	+ // integer part
	8337	+ if (exponent <= 0)
	8338	+ {
	8339	+ *s++ = '0';
	8340	+ }
	8341	+ else
	8342	+ {
	8343	+ while (exponent > 0)
	8344	+ {
	8345	+ assert(mantissa == 0 \|\| static_cast<unsigned int>(mantissa - '0') <= 9);
	8346	+ s++ = mantissa ? *mantissa++ : '0';
	8347	+ exponent--;
	8348	+ }
	8349	+ }
	8350	+
	8351	+ // fractional part
	8352	+ if (*mantissa)
	8353	+ {
	8354	+ // decimal point
	8355	+ *s++ = '.';
	8356	+
	8357	+ // extra zeroes from negative exponent
	8358	+ while (exponent < 0)
	8359	+ {
	8360	+ *s++ = '0';
	8361	+ exponent++;
	8362	+ }
	8363	+
	8364	+ // extra mantissa digits
	8365	+ while (*mantissa)
	8366	+ {
	8367	+ assert(static_cast<unsigned int>(*mantissa - '0') <= 9);
	8368	+ s++ = mantissa++;
	8369	+ }
	8370	+ }
	8371	+
	8372	+ // zero-terminate
	8373	+ assert(s < result + result_size);
	8374	+ *s = 0;
	8375	+
	8376	+ return xpath_string::from_heap_preallocated(result, s);
	8377	+ }
	8378	+
	8379	+ PUGI__FN bool check_string_to_number_format(const char_t* string)
	8380	+ {
	8381	+ // parse leading whitespace
	8382	+ while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;
	8383	+
	8384	+ // parse sign
	8385	+ if (*string == '-') ++string;
	8386	+
	8387	+ if (!*string) return false;
	8388	+
	8389	+ // if there is no integer part, there should be a decimal part with at least one digit
	8390	+ if (!PUGI__IS_CHARTYPEX(string[0], ctx_digit) && (string[0] != '.' \|\| !PUGI__IS_CHARTYPEX(string[1], ctx_digit))) return false;
	8391	+
	8392	+ // parse integer part
	8393	+ while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;
	8394	+
	8395	+ // parse decimal part
	8396	+ if (*string == '.')
	8397	+ {
	8398	+ ++string;
	8399	+
	8400	+ while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;
	8401	+ }
	8402	+
	8403	+ // parse trailing whitespace
	8404	+ while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;
	8405	+
	8406	+ return *string == 0;
	8407	+ }
	8408	+
	8409	+ PUGI__FN double convert_string_to_number(const char_t* string)
	8410	+ {
	8411	+ // check string format
	8412	+ if (!check_string_to_number_format(string)) return gen_nan();
	8413	+
	8414	+ // parse string
	8415	+ #ifdef PUGIXML_WCHAR_MODE
	8416	+ return wcstod(string, 0);
	8417	+ #else
	8418	+ return strtod(string, 0);
	8419	+ #endif
	8420	+ }
	8421	+
	8422	+ PUGI__FN bool convert_string_to_number_scratch(char_t (&buffer)[32], const char_t* begin, const char_t* end, double* out_result)
	8423	+ {
	8424	+ size_t length = static_cast<size_t>(end - begin);
	8425	+ char_t* scratch = buffer;
	8426	+
	8427	+ if (length >= sizeof(buffer) / sizeof(buffer[0]))
	8428	+ {
	8429	+ // need to make dummy on-heap copy
	8430	+ scratch = static_cast<char_t>(xml_memory::allocate((length + 1) sizeof(char_t)));
	8431	+ if (!scratch) return false;
	8432	+ }
	8433	+
	8434	+ // copy string to zero-terminated buffer and perform conversion
	8435	+ memcpy(scratch, begin, length * sizeof(char_t));
	8436	+ scratch[length] = 0;
	8437	+
	8438	+ *out_result = convert_string_to_number(scratch);
	8439	+
	8440	+ // free dummy buffer
	8441	+ if (scratch != buffer) xml_memory::deallocate(scratch);
	8442	+
	8443	+ return true;
	8444	+ }
	8445	+
	8446	+ PUGI__FN double round_nearest(double value)
	8447	+ {
	8448	+ return floor(value + 0.5);
	8449	+ }
	8450	+
	8451	+ PUGI__FN double round_nearest_nzero(double value)
	8452	+ {
	8453	+ // same as round_nearest, but returns -0 for [-0.5, -0]
	8454	+ // ceil is used to differentiate between +0 and -0 (we return -0 for [-0.5, -0] and +0 for +0)
	8455	+ return (value >= -0.5 && value <= 0) ? ceil(value) : floor(value + 0.5);
	8456	+ }
	8457	+
	8458	+ PUGI__FN const char_t* qualified_name(const xpath_node& node)
	8459	+ {
	8460	+ return node.attribute() ? node.attribute().name() : node.node().name();
	8461	+ }
	8462	+
	8463	+ PUGI__FN const char_t* local_name(const xpath_node& node)
	8464	+ {
	8465	+ const char_t* name = qualified_name(node);
	8466	+ const char_t* p = find_char(name, ':');
	8467	+
	8468	+ return p ? p + 1 : name;
	8469	+ }
	8470	+
	8471	+ struct namespace_uri_predicate
	8472	+ {
	8473	+ const char_t* prefix;
	8474	+ size_t prefix_length;
	8475	+
	8476	+ namespace_uri_predicate(const char_t* name)
	8477	+ {
	8478	+ const char_t* pos = find_char(name, ':');
	8479	+
	8480	+ prefix = pos ? name : 0;
	8481	+ prefix_length = pos ? static_cast<size_t>(pos - name) : 0;
	8482	+ }
	8483	+
	8484	+ bool operator()(xml_attribute a) const
	8485	+ {
	8486	+ const char_t* name = a.name();
	8487	+
	8488	+ if (!starts_with(name, PUGIXML_TEXT("xmlns"))) return false;
	8489	+
	8490	+ return prefix ? name[5] == ':' && strequalrange(name + 6, prefix, prefix_length) : name[5] == 0;
	8491	+ }
	8492	+ };
	8493	+
	8494	+ PUGI__FN const char_t* namespace_uri(xml_node node)
	8495	+ {
	8496	+ namespace_uri_predicate pred = node.name();
	8497	+
	8498	+ xml_node p = node;
	8499	+
	8500	+ while (p)
	8501	+ {
	8502	+ xml_attribute a = p.find_attribute(pred);
	8503	+
	8504	+ if (a) return a.value();
	8505	+
	8506	+ p = p.parent();
	8507	+ }
	8508	+
	8509	+ return PUGIXML_TEXT("");
	8510	+ }
	8511	+
	8512	+ PUGI__FN const char_t* namespace_uri(xml_attribute attr, xml_node parent)
	8513	+ {
	8514	+ namespace_uri_predicate pred = attr.name();
	8515	+
	8516	+ // Default namespace does not apply to attributes
	8517	+ if (!pred.prefix) return PUGIXML_TEXT("");
	8518	+
	8519	+ xml_node p = parent;
	8520	+
	8521	+ while (p)
	8522	+ {
	8523	+ xml_attribute a = p.find_attribute(pred);
	8524	+
	8525	+ if (a) return a.value();
	8526	+
	8527	+ p = p.parent();
	8528	+ }
	8529	+
	8530	+ return PUGIXML_TEXT("");
	8531	+ }
	8532	+
	8533	+ PUGI__FN const char_t* namespace_uri(const xpath_node& node)
	8534	+ {
	8535	+ return node.attribute() ? namespace_uri(node.attribute(), node.parent()) : namespace_uri(node.node());
	8536	+ }
	8537	+
	8538	+ PUGI__FN char_t* normalize_space(char_t* buffer)
	8539	+ {
	8540	+ char_t* write = buffer;
	8541	+
	8542	+ for (char_t* it = buffer; *it; )
	8543	+ {
	8544	+ char_t ch = *it++;
	8545	+
	8546	+ if (PUGI__IS_CHARTYPE(ch, ct_space))
	8547	+ {
	8548	+ // replace whitespace sequence with single space
	8549	+ while (PUGI__IS_CHARTYPE(*it, ct_space)) it++;
	8550	+
	8551	+ // avoid leading spaces
	8552	+ if (write != buffer) *write++ = ' ';
	8553	+ }
	8554	+ else *write++ = ch;
	8555	+ }
	8556	+
	8557	+ // remove trailing space
	8558	+ if (write != buffer && PUGI__IS_CHARTYPE(write[-1], ct_space)) write--;
	8559	+
	8560	+ // zero-terminate
	8561	+ *write = 0;
	8562	+
	8563	+ return write;
	8564	+ }
	8565	+
	8566	+ PUGI__FN char_t* translate(char_t* buffer, const char_t* from, const char_t* to, size_t to_length)
	8567	+ {
	8568	+ char_t* write = buffer;
	8569	+
	8570	+ while (*buffer)
	8571	+ {
	8572	+ PUGI__DMC_VOLATILE char_t ch = *buffer++;
	8573	+
	8574	+ const char_t* pos = find_char(from, ch);
	8575	+
	8576	+ if (!pos)
	8577	+ *write++ = ch; // do not process
	8578	+ else if (static_cast<size_t>(pos - from) < to_length)
	8579	+ *write++ = to[pos - from]; // replace
	8580	+ }
	8581	+
	8582	+ // zero-terminate
	8583	+ *write = 0;
	8584	+
	8585	+ return write;
	8586	+ }
	8587	+
	8588	+ PUGI__FN unsigned char* translate_table_generate(xpath_allocator* alloc, const char_t* from, const char_t* to)
	8589	+ {
	8590	+ unsigned char table[128] = {0};
	8591	+
	8592	+ while (*from)
	8593	+ {
	8594	+ unsigned int fc = static_cast<unsigned int>(*from);
	8595	+ unsigned int tc = static_cast<unsigned int>(*to);
	8596	+
	8597	+ if (fc >= 128 \|\| tc >= 128)
	8598	+ return 0;
	8599	+
	8600	+ // code=128 means "skip character"
	8601	+ if (!table[fc])
	8602	+ table[fc] = static_cast<unsigned char>(tc ? tc : 128);
	8603	+
	8604	+ from++;
	8605	+ if (tc) to++;
	8606	+ }
	8607	+
	8608	+ for (int i = 0; i < 128; ++i)
	8609	+ if (!table[i])
	8610	+ table[i] = static_cast<unsigned char>(i);
	8611	+
	8612	+ void* result = alloc->allocate(sizeof(table));
	8613	+ if (!result) return 0;
	8614	+
	8615	+ memcpy(result, table, sizeof(table));
	8616	+
	8617	+ return static_cast<unsigned char*>(result);
	8618	+ }
	8619	+
	8620	+ PUGI__FN char_t* translate_table(char_t* buffer, const unsigned char* table)
	8621	+ {
	8622	+ char_t* write = buffer;
	8623	+
	8624	+ while (*buffer)
	8625	+ {
	8626	+ char_t ch = *buffer++;
	8627	+ unsigned int index = static_cast<unsigned int>(ch);
	8628	+
	8629	+ if (index < 128)
	8630	+ {
	8631	+ unsigned char code = table[index];
	8632	+
	8633	+ // code=128 means "skip character" (table size is 128 so 128 can be a special value)
	8634	+ // this code skips these characters without extra branches
	8635	+ *write = static_cast<char_t>(code);
	8636	+ write += 1 - (code >> 7);
	8637	+ }
	8638	+ else
	8639	+ {
	8640	+ *write++ = ch;
	8641	+ }
	8642	+ }
	8643	+
	8644	+ // zero-terminate
	8645	+ *write = 0;
	8646	+
	8647	+ return write;
	8648	+ }
	8649	+
	8650	+ inline bool is_xpath_attribute(const char_t* name)
	8651	+ {
	8652	+ return !(starts_with(name, PUGIXML_TEXT("xmlns")) && (name[5] == 0 \|\| name[5] == ':'));
	8653	+ }
	8654	+
	8655	+ struct xpath_variable_boolean: xpath_variable
	8656	+ {
	8657	+ xpath_variable_boolean(): xpath_variable(xpath_type_boolean), value(false)
	8658	+ {
	8659	+ }
	8660	+
	8661	+ bool value;
	8662	+ char_t name[1];
	8663	+ };
	8664	+
	8665	+ struct xpath_variable_number: xpath_variable
	8666	+ {
	8667	+ xpath_variable_number(): xpath_variable(xpath_type_number), value(0)
	8668	+ {
	8669	+ }
	8670	+
	8671	+ double value;
	8672	+ char_t name[1];
	8673	+ };
	8674	+
	8675	+ struct xpath_variable_string: xpath_variable
	8676	+ {
	8677	+ xpath_variable_string(): xpath_variable(xpath_type_string), value(0)
	8678	+ {
	8679	+ }
	8680	+
	8681	+ ~xpath_variable_string()
	8682	+ {
	8683	+ if (value) xml_memory::deallocate(value);
	8684	+ }
	8685	+
	8686	+ char_t* value;
	8687	+ char_t name[1];
	8688	+ };
	8689	+
	8690	+ struct xpath_variable_node_set: xpath_variable
	8691	+ {
	8692	+ xpath_variable_node_set(): xpath_variable(xpath_type_node_set)
	8693	+ {
	8694	+ }
	8695	+
	8696	+ xpath_node_set value;
	8697	+ char_t name[1];
	8698	+ };
	8699	+
	8700	+ static const xpath_node_set dummy_node_set;
	8701	+
	8702	+ PUGI__FN PUGI__UNSIGNED_OVERFLOW unsigned int hash_string(const char_t* str)
	8703	+ {
	8704	+ // Jenkins one-at-a-time hash (http://en.wikipedia.org/wiki/Jenkins_hash_function#one-at-a-time)
	8705	+ unsigned int result = 0;
	8706	+
	8707	+ while (*str)
	8708	+ {
	8709	+ result += static_cast<unsigned int>(*str++);
	8710	+ result += result << 10;
	8711	+ result ^= result >> 6;
	8712	+ }
	8713	+
	8714	+ result += result << 3;
	8715	+ result ^= result >> 11;
	8716	+ result += result << 15;
	8717	+
	8718	+ return result;
	8719	+ }
	8720	+
	8721	+ template <typename T> PUGI__FN T* new_xpath_variable(const char_t* name)
	8722	+ {
	8723	+ size_t length = strlength(name);
	8724	+ if (length == 0) return 0; // empty variable names are invalid
	8725	+
	8726	+ // $$ we can't use offsetof(T, name) because T is non-POD, so we just allocate additional length characters
	8727	+ void* memory = xml_memory::allocate(sizeof(T) + length * sizeof(char_t));
	8728	+ if (!memory) return 0;
	8729	+
	8730	+ T* result = new (memory) T();
	8731	+
	8732	+ memcpy(result->name, name, (length + 1) * sizeof(char_t));
	8733	+
	8734	+ return result;
	8735	+ }
	8736	+
	8737	+ PUGI__FN xpath_variable* new_xpath_variable(xpath_value_type type, const char_t* name)
	8738	+ {
	8739	+ switch (type)
	8740	+ {
	8741	+ case xpath_type_node_set:
	8742	+ return new_xpath_variable<xpath_variable_node_set>(name);
	8743	+
	8744	+ case xpath_type_number:
	8745	+ return new_xpath_variable<xpath_variable_number>(name);
	8746	+
	8747	+ case xpath_type_string:
	8748	+ return new_xpath_variable<xpath_variable_string>(name);
	8749	+
	8750	+ case xpath_type_boolean:
	8751	+ return new_xpath_variable<xpath_variable_boolean>(name);
	8752	+
	8753	+ default:
	8754	+ return 0;
	8755	+ }
	8756	+ }
	8757	+
	8758	+ template <typename T> PUGI__FN void delete_xpath_variable(T* var)
	8759	+ {
	8760	+ var->~T();
	8761	+ xml_memory::deallocate(var);
	8762	+ }
	8763	+
	8764	+ PUGI__FN void delete_xpath_variable(xpath_value_type type, xpath_variable* var)
	8765	+ {
	8766	+ switch (type)
	8767	+ {
	8768	+ case xpath_type_node_set:
	8769	+ delete_xpath_variable(static_cast<xpath_variable_node_set*>(var));
	8770	+ break;
	8771	+
	8772	+ case xpath_type_number:
	8773	+ delete_xpath_variable(static_cast<xpath_variable_number*>(var));
	8774	+ break;
	8775	+
	8776	+ case xpath_type_string:
	8777	+ delete_xpath_variable(static_cast<xpath_variable_string*>(var));
	8778	+ break;
	8779	+
	8780	+ case xpath_type_boolean:
	8781	+ delete_xpath_variable(static_cast<xpath_variable_boolean*>(var));
	8782	+ break;
	8783	+
	8784	+ default:
	8785	+ assert(false && "Invalid variable type"); // unreachable
	8786	+ }
	8787	+ }
	8788	+
	8789	+ PUGI__FN bool copy_xpath_variable(xpath_variable* lhs, const xpath_variable* rhs)
	8790	+ {
	8791	+ switch (rhs->type())
	8792	+ {
	8793	+ case xpath_type_node_set:
	8794	+ return lhs->set(static_cast<const xpath_variable_node_set*>(rhs)->value);
	8795	+
	8796	+ case xpath_type_number:
	8797	+ return lhs->set(static_cast<const xpath_variable_number*>(rhs)->value);
	8798	+
	8799	+ case xpath_type_string:
	8800	+ return lhs->set(static_cast<const xpath_variable_string*>(rhs)->value);
	8801	+
	8802	+ case xpath_type_boolean:
	8803	+ return lhs->set(static_cast<const xpath_variable_boolean*>(rhs)->value);
	8804	+
	8805	+ default:
	8806	+ assert(false && "Invalid variable type"); // unreachable
	8807	+ return false;
	8808	+ }
	8809	+ }
	8810	+
	8811	+ 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)
	8812	+ {
	8813	+ size_t length = static_cast<size_t>(end - begin);
	8814	+ char_t* scratch = buffer;
	8815	+
	8816	+ if (length >= sizeof(buffer) / sizeof(buffer[0]))
	8817	+ {
	8818	+ // need to make dummy on-heap copy
	8819	+ scratch = static_cast<char_t>(xml_memory::allocate((length + 1) sizeof(char_t)));
	8820	+ if (!scratch) return false;
	8821	+ }
	8822	+
	8823	+ // copy string to zero-terminated buffer and perform lookup
	8824	+ memcpy(scratch, begin, length * sizeof(char_t));
	8825	+ scratch[length] = 0;
	8826	+
	8827	+ *out_result = set->get(scratch);
	8828	+
	8829	+ // free dummy buffer
	8830	+ if (scratch != buffer) xml_memory::deallocate(scratch);
	8831	+
	8832	+ return true;
	8833	+ }
	8834	+PUGI__NS_END
	8835	+
	8836	+// Internal node set class
	8837	+PUGI__NS_BEGIN
	8838	+ PUGI__FN xpath_node_set::type_t xpath_get_order(const xpath_node* begin, const xpath_node* end)
	8839	+ {
	8840	+ if (end - begin < 2)
	8841	+ return xpath_node_set::type_sorted;
	8842	+
	8843	+ document_order_comparator cmp;
	8844	+
	8845	+ bool first = cmp(begin[0], begin[1]);
	8846	+
	8847	+ for (const xpath_node* it = begin + 1; it + 1 < end; ++it)
	8848	+ if (cmp(it[0], it[1]) != first)
	8849	+ return xpath_node_set::type_unsorted;
	8850	+
	8851	+ return first ? xpath_node_set::type_sorted : xpath_node_set::type_sorted_reverse;
	8852	+ }
	8853	+
	8854	+ PUGI__FN xpath_node_set::type_t xpath_sort(xpath_node* begin, xpath_node* end, xpath_node_set::type_t type, bool rev)
	8855	+ {
	8856	+ xpath_node_set::type_t order = rev ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted;
	8857	+
	8858	+ if (type == xpath_node_set::type_unsorted)
	8859	+ {
	8860	+ xpath_node_set::type_t sorted = xpath_get_order(begin, end);
	8861	+
	8862	+ if (sorted == xpath_node_set::type_unsorted)
	8863	+ {
	8864	+ sort(begin, end, document_order_comparator());
	8865	+
	8866	+ type = xpath_node_set::type_sorted;
	8867	+ }
	8868	+ else
	8869	+ type = sorted;
	8870	+ }
	8871	+
	8872	+ if (type != order) reverse(begin, end);
	8873	+
	8874	+ return order;
	8875	+ }
	8876	+
	8877	+ PUGI__FN xpath_node xpath_first(const xpath_node* begin, const xpath_node* end, xpath_node_set::type_t type)
	8878	+ {
	8879	+ if (begin == end) return xpath_node();
	8880	+
	8881	+ switch (type)
	8882	+ {
	8883	+ case xpath_node_set::type_sorted:
	8884	+ return *begin;
	8885	+
	8886	+ case xpath_node_set::type_sorted_reverse:
	8887	+ return *(end - 1);
	8888	+
	8889	+ case xpath_node_set::type_unsorted:
	8890	+ return *min_element(begin, end, document_order_comparator());
	8891	+
	8892	+ default:
	8893	+ assert(false && "Invalid node set type"); // unreachable
	8894	+ return xpath_node();
	8895	+ }
	8896	+ }
	8897	+
	8898	+ class xpath_node_set_raw
	8899	+ {
	8900	+ xpath_node_set::type_t _type;
	8901	+
	8902	+ xpath_node* _begin;
	8903	+ xpath_node* _end;
	8904	+ xpath_node* _eos;
	8905	+
	8906	+ public:
	8907	+ xpath_node_set_raw(): _type(xpath_node_set::type_unsorted), _begin(0), _end(0), _eos(0)
	8908	+ {
	8909	+ }
	8910	+
	8911	+ xpath_node* begin() const
	8912	+ {
	8913	+ return _begin;
	8914	+ }
	8915	+
	8916	+ xpath_node* end() const
	8917	+ {
	8918	+ return _end;
	8919	+ }
	8920	+
	8921	+ bool empty() const
	8922	+ {
	8923	+ return _begin == _end;
	8924	+ }
	8925	+
	8926	+ size_t size() const
	8927	+ {
	8928	+ return static_cast<size_t>(_end - _begin);
	8929	+ }
	8930	+
	8931	+ xpath_node first() const
	8932	+ {
	8933	+ return xpath_first(_begin, _end, _type);
	8934	+ }
	8935	+
	8936	+ void push_back_grow(const xpath_node& node, xpath_allocator* alloc);
	8937	+
	8938	+ void push_back(const xpath_node& node, xpath_allocator* alloc)
	8939	+ {
	8940	+ if (_end != _eos)
	8941	+ *_end++ = node;
	8942	+ else
	8943	+ push_back_grow(node, alloc);
	8944	+ }
	8945	+
	8946	+ void append(const xpath_node* begin_, const xpath_node* end_, xpath_allocator* alloc)
	8947	+ {
	8948	+ if (begin_ == end_) return;
	8949	+
	8950	+ size_t size_ = static_cast<size_t>(_end - _begin);
	8951	+ size_t capacity = static_cast<size_t>(_eos - _begin);
	8952	+ size_t count = static_cast<size_t>(end_ - begin_);
	8953	+
	8954	+ if (size_ + count > capacity)
	8955	+ {
	8956	+ // reallocate the old array or allocate a new one
	8957	+ xpath_node* data = static_cast<xpath_node>(alloc->reallocate(_begin, capacity sizeof(xpath_node), (size_ + count) * sizeof(xpath_node)));
	8958	+ if (!data) return;
	8959	+
	8960	+ // finalize
	8961	+ _begin = data;
	8962	+ _end = data + size_;
	8963	+ _eos = data + size_ + count;
	8964	+ }
	8965	+
	8966	+ memcpy(_end, begin_, count * sizeof(xpath_node));
	8967	+ _end += count;
	8968	+ }
	8969	+
	8970	+ void sort_do()
	8971	+ {
	8972	+ _type = xpath_sort(_begin, _end, _type, false);
	8973	+ }
	8974	+
	8975	+ void truncate(xpath_node* pos)
	8976	+ {
	8977	+ assert(_begin <= pos && pos <= _end);
	8978	+
	8979	+ _end = pos;
	8980	+ }
	8981	+
	8982	+ void remove_duplicates(xpath_allocator* alloc)
	8983	+ {
	8984	+ if (_type == xpath_node_set::type_unsorted && _end - _begin > 2)
	8985	+ {
	8986	+ xpath_allocator_capture cr(alloc);
	8987	+
	8988	+ size_t size_ = static_cast<size_t>(_end - _begin);
	8989	+
	8990	+ size_t hash_size = 1;
	8991	+ while (hash_size < size_ + size_ / 2) hash_size *= 2;
	8992	+
	8993	+ const void hash_data = static_cast<const void>(alloc->allocate(hash_size * sizeof(void**)));
	8994	+ if (!hash_data) return;
	8995	+
	8996	+ memset(hash_data, 0, hash_size * sizeof(const void**));
	8997	+
	8998	+ xpath_node* write = _begin;
	8999	+
	9000	+ for (xpath_node* it = _begin; it != _end; ++it)
	9001	+ {
	9002	+ const void* attr = it->attribute().internal_object();
	9003	+ const void* node = it->node().internal_object();
	9004	+ const void* key = attr ? attr : node;
	9005	+
	9006	+ if (key && hash_insert(hash_data, hash_size, key))
	9007	+ {
	9008	+ write++ = it;
	9009	+ }
	9010	+ }
	9011	+
	9012	+ _end = write;
	9013	+ }
	9014	+ else
	9015	+ {
	9016	+ _end = unique(_begin, _end);
	9017	+ }
	9018	+ }
	9019	+
	9020	+ xpath_node_set::type_t type() const
	9021	+ {
	9022	+ return _type;
	9023	+ }
	9024	+
	9025	+ void set_type(xpath_node_set::type_t value)
	9026	+ {
	9027	+ _type = value;
	9028	+ }
	9029	+ };
	9030	+
	9031	+ PUGI__FN_NO_INLINE void xpath_node_set_raw::push_back_grow(const xpath_node& node, xpath_allocator* alloc)
	9032	+ {
	9033	+ size_t capacity = static_cast<size_t>(_eos - _begin);
	9034	+
	9035	+ // get new capacity (1.5x rule)
	9036	+ size_t new_capacity = capacity + capacity / 2 + 1;
	9037	+
	9038	+ // reallocate the old array or allocate a new one
	9039	+ xpath_node* data = static_cast<xpath_node>(alloc->reallocate(_begin, capacity sizeof(xpath_node), new_capacity * sizeof(xpath_node)));
	9040	+ if (!data) return;
	9041	+
	9042	+ // finalize
	9043	+ _begin = data;
	9044	+ _end = data + capacity;
	9045	+ _eos = data + new_capacity;
	9046	+
	9047	+ // push
	9048	+ *_end++ = node;
	9049	+ }
	9050	+PUGI__NS_END
	9051	+
	9052	+PUGI__NS_BEGIN
	9053	+ struct xpath_context
	9054	+ {
	9055	+ xpath_node n;
	9056	+ size_t position, size;
	9057	+
	9058	+ xpath_context(const xpath_node& n_, size_t position_, size_t size_): n(n_), position(position_), size(size_)
	9059	+ {
	9060	+ }
	9061	+ };
	9062	+
	9063	+ enum lexeme_t
	9064	+ {
	9065	+ lex_none = 0,
	9066	+ lex_equal,
	9067	+ lex_not_equal,
	9068	+ lex_less,
	9069	+ lex_greater,
	9070	+ lex_less_or_equal,
	9071	+ lex_greater_or_equal,
	9072	+ lex_plus,
	9073	+ lex_minus,
	9074	+ lex_multiply,
	9075	+ lex_union,
	9076	+ lex_var_ref,
	9077	+ lex_open_brace,
	9078	+ lex_close_brace,
	9079	+ lex_quoted_string,
	9080	+ lex_number,
	9081	+ lex_slash,
	9082	+ lex_double_slash,
	9083	+ lex_open_square_brace,
	9084	+ lex_close_square_brace,
	9085	+ lex_string,
	9086	+ lex_comma,
	9087	+ lex_axis_attribute,
	9088	+ lex_dot,
	9089	+ lex_double_dot,
	9090	+ lex_double_colon,
	9091	+ lex_eof
	9092	+ };
	9093	+
	9094	+ struct xpath_lexer_string
	9095	+ {
	9096	+ const char_t* begin;
	9097	+ const char_t* end;
	9098	+
	9099	+ xpath_lexer_string(): begin(0), end(0)
	9100	+ {
	9101	+ }
	9102	+
	9103	+ bool operator==(const char_t* other) const
	9104	+ {
	9105	+ size_t length = static_cast<size_t>(end - begin);
	9106	+
	9107	+ return strequalrange(other, begin, length);
	9108	+ }
	9109	+ };
	9110	+
	9111	+ class xpath_lexer
	9112	+ {
	9113	+ const char_t* _cur;
	9114	+ const char_t* _cur_lexeme_pos;
	9115	+ xpath_lexer_string _cur_lexeme_contents;
	9116	+
	9117	+ lexeme_t _cur_lexeme;
	9118	+
	9119	+ public:
	9120	+ explicit xpath_lexer(const char_t* query): _cur(query)
	9121	+ {
	9122	+ next();
	9123	+ }
	9124	+
	9125	+ const char_t* state() const
	9126	+ {
	9127	+ return _cur;
	9128	+ }
	9129	+
	9130	+ void next()
	9131	+ {
	9132	+ const char_t* cur = _cur;
	9133	+
	9134	+ while (PUGI__IS_CHARTYPE(*cur, ct_space)) ++cur;
	9135	+
	9136	+ // save lexeme position for error reporting
	9137	+ _cur_lexeme_pos = cur;
	9138	+
	9139	+ switch (*cur)
	9140	+ {
	9141	+ case 0:
	9142	+ _cur_lexeme = lex_eof;
	9143	+ break;
	9144	+
	9145	+ case '>':
	9146	+ if (*(cur+1) == '=')
	9147	+ {
	9148	+ cur += 2;
	9149	+ _cur_lexeme = lex_greater_or_equal;
	9150	+ }
	9151	+ else
	9152	+ {
	9153	+ cur += 1;
	9154	+ _cur_lexeme = lex_greater;
	9155	+ }
	9156	+ break;
	9157	+
	9158	+ case '<':
	9159	+ if (*(cur+1) == '=')
	9160	+ {
	9161	+ cur += 2;
	9162	+ _cur_lexeme = lex_less_or_equal;
	9163	+ }
	9164	+ else
	9165	+ {
	9166	+ cur += 1;
	9167	+ _cur_lexeme = lex_less;
	9168	+ }
	9169	+ break;
	9170	+
	9171	+ case '!':
	9172	+ if (*(cur+1) == '=')
	9173	+ {
	9174	+ cur += 2;
	9175	+ _cur_lexeme = lex_not_equal;
	9176	+ }
	9177	+ else
	9178	+ {
	9179	+ _cur_lexeme = lex_none;
	9180	+ }
	9181	+ break;
	9182	+
	9183	+ case '=':
	9184	+ cur += 1;
	9185	+ _cur_lexeme = lex_equal;
	9186	+
	9187	+ break;
	9188	+
	9189	+ case '+':
	9190	+ cur += 1;
	9191	+ _cur_lexeme = lex_plus;
	9192	+
	9193	+ break;
	9194	+
	9195	+ case '-':
	9196	+ cur += 1;
	9197	+ _cur_lexeme = lex_minus;
	9198	+
	9199	+ break;
	9200	+
	9201	+ case '*':
	9202	+ cur += 1;
	9203	+ _cur_lexeme = lex_multiply;
	9204	+
	9205	+ break;
	9206	+
	9207	+ case '\|':
	9208	+ cur += 1;
	9209	+ _cur_lexeme = lex_union;
	9210	+
	9211	+ break;
	9212	+
	9213	+ case '$':
	9214	+ cur += 1;
	9215	+
	9216	+ if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol))
	9217	+ {
	9218	+ _cur_lexeme_contents.begin = cur;
	9219	+
	9220	+ while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
	9221	+
	9222	+ if (cur[0] == ':' && PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // qname
	9223	+ {
	9224	+ cur++; // :
	9225	+
	9226	+ while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
	9227	+ }
	9228	+
	9229	+ _cur_lexeme_contents.end = cur;
	9230	+
	9231	+ _cur_lexeme = lex_var_ref;
	9232	+ }
	9233	+ else
	9234	+ {
	9235	+ _cur_lexeme = lex_none;
	9236	+ }
	9237	+
	9238	+ break;
	9239	+
	9240	+ case '(':
	9241	+ cur += 1;
	9242	+ _cur_lexeme = lex_open_brace;
	9243	+
	9244	+ break;
	9245	+
	9246	+ case ')':
	9247	+ cur += 1;
	9248	+ _cur_lexeme = lex_close_brace;
	9249	+
	9250	+ break;
	9251	+
	9252	+ case '[':
	9253	+ cur += 1;
	9254	+ _cur_lexeme = lex_open_square_brace;
	9255	+
	9256	+ break;
	9257	+
	9258	+ case ']':
	9259	+ cur += 1;
	9260	+ _cur_lexeme = lex_close_square_brace;
	9261	+
	9262	+ break;
	9263	+
	9264	+ case ',':
	9265	+ cur += 1;
	9266	+ _cur_lexeme = lex_comma;
	9267	+
	9268	+ break;
	9269	+
	9270	+ case '/':
	9271	+ if (*(cur+1) == '/')
	9272	+ {
	9273	+ cur += 2;
	9274	+ _cur_lexeme = lex_double_slash;
	9275	+ }
	9276	+ else
	9277	+ {
	9278	+ cur += 1;
	9279	+ _cur_lexeme = lex_slash;
	9280	+ }
	9281	+ break;
	9282	+
	9283	+ case '.':
	9284	+ if (*(cur+1) == '.')
	9285	+ {
	9286	+ cur += 2;
	9287	+ _cur_lexeme = lex_double_dot;
	9288	+ }
	9289	+ else if (PUGI__IS_CHARTYPEX(*(cur+1), ctx_digit))
	9290	+ {
	9291	+ _cur_lexeme_contents.begin = cur; // .
	9292	+
	9293	+ ++cur;
	9294	+
	9295	+ while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
	9296	+
	9297	+ _cur_lexeme_contents.end = cur;
	9298	+
	9299	+ _cur_lexeme = lex_number;
	9300	+ }
	9301	+ else
	9302	+ {
	9303	+ cur += 1;
	9304	+ _cur_lexeme = lex_dot;
	9305	+ }
	9306	+ break;
	9307	+
	9308	+ case '@':
	9309	+ cur += 1;
	9310	+ _cur_lexeme = lex_axis_attribute;
	9311	+
	9312	+ break;
	9313	+
	9314	+ case '"':
	9315	+ case '\'':
	9316	+ {
	9317	+ char_t terminator = *cur;
	9318	+
	9319	+ ++cur;
	9320	+
	9321	+ _cur_lexeme_contents.begin = cur;
	9322	+ while (cur && cur != terminator) cur++;
	9323	+ _cur_lexeme_contents.end = cur;
	9324	+
	9325	+ if (!*cur)
	9326	+ _cur_lexeme = lex_none;
	9327	+ else
	9328	+ {
	9329	+ cur += 1;
	9330	+ _cur_lexeme = lex_quoted_string;
	9331	+ }
	9332	+
	9333	+ break;
	9334	+ }
	9335	+
	9336	+ case ':':
	9337	+ if (*(cur+1) == ':')
	9338	+ {
	9339	+ cur += 2;
	9340	+ _cur_lexeme = lex_double_colon;
	9341	+ }
	9342	+ else
	9343	+ {
	9344	+ _cur_lexeme = lex_none;
	9345	+ }
	9346	+ break;
	9347	+
	9348	+ default:
	9349	+ if (PUGI__IS_CHARTYPEX(*cur, ctx_digit))
	9350	+ {
	9351	+ _cur_lexeme_contents.begin = cur;
	9352	+
	9353	+ while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
	9354	+
	9355	+ if (*cur == '.')
	9356	+ {
	9357	+ cur++;
	9358	+
	9359	+ while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
	9360	+ }
	9361	+
	9362	+ _cur_lexeme_contents.end = cur;
	9363	+
	9364	+ _cur_lexeme = lex_number;
	9365	+ }
	9366	+ else if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol))
	9367	+ {
	9368	+ _cur_lexeme_contents.begin = cur;
	9369	+
	9370	+ while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
	9371	+
	9372	+ if (cur[0] == ':')
	9373	+ {
	9374	+ if (cur[1] == '') // namespace test ncname:
	9375	+ {
	9376	+ cur += 2; // :*
	9377	+ }
	9378	+ else if (PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // namespace test qname
	9379	+ {
	9380	+ cur++; // :
	9381	+
	9382	+ while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
	9383	+ }
	9384	+ }
	9385	+
	9386	+ _cur_lexeme_contents.end = cur;
	9387	+
	9388	+ _cur_lexeme = lex_string;
	9389	+ }
	9390	+ else
	9391	+ {
	9392	+ _cur_lexeme = lex_none;
	9393	+ }
	9394	+ }
	9395	+
	9396	+ _cur = cur;
	9397	+ }
	9398	+
	9399	+ lexeme_t current() const
	9400	+ {
	9401	+ return _cur_lexeme;
	9402	+ }
	9403	+
	9404	+ const char_t* current_pos() const
	9405	+ {
	9406	+ return _cur_lexeme_pos;
	9407	+ }
	9408	+
	9409	+ const xpath_lexer_string& contents() const
	9410	+ {
	9411	+ assert(_cur_lexeme == lex_var_ref \|\| _cur_lexeme == lex_number \|\| _cur_lexeme == lex_string \|\| _cur_lexeme == lex_quoted_string);
	9412	+
	9413	+ return _cur_lexeme_contents;
	9414	+ }
	9415	+ };
	9416	+
	9417	+ enum ast_type_t
	9418	+ {
	9419	+ ast_unknown,
	9420	+ ast_op_or, // left or right
	9421	+ ast_op_and, // left and right
	9422	+ ast_op_equal, // left = right
	9423	+ ast_op_not_equal, // left != right
	9424	+ ast_op_less, // left < right
	9425	+ ast_op_greater, // left > right
	9426	+ ast_op_less_or_equal, // left <= right
	9427	+ ast_op_greater_or_equal, // left >= right
	9428	+ ast_op_add, // left + right
	9429	+ ast_op_subtract, // left - right
	9430	+ ast_op_multiply, // left * right
	9431	+ ast_op_divide, // left / right
	9432	+ ast_op_mod, // left % right
	9433	+ ast_op_negate, // left - right
	9434	+ ast_op_union, // left \| right
	9435	+ ast_predicate, // apply predicate to set; next points to next predicate
	9436	+ ast_filter, // select * from left where right
	9437	+ ast_string_constant, // string constant
	9438	+ ast_number_constant, // number constant
	9439	+ ast_variable, // variable
	9440	+ ast_func_last, // last()
	9441	+ ast_func_position, // position()
	9442	+ ast_func_count, // count(left)
	9443	+ ast_func_id, // id(left)
	9444	+ ast_func_local_name_0, // local-name()
	9445	+ ast_func_local_name_1, // local-name(left)
	9446	+ ast_func_namespace_uri_0, // namespace-uri()
	9447	+ ast_func_namespace_uri_1, // namespace-uri(left)
	9448	+ ast_func_name_0, // name()
	9449	+ ast_func_name_1, // name(left)
	9450	+ ast_func_string_0, // string()
	9451	+ ast_func_string_1, // string(left)
	9452	+ ast_func_concat, // concat(left, right, siblings)
	9453	+ ast_func_starts_with, // starts_with(left, right)
	9454	+ ast_func_contains, // contains(left, right)
	9455	+ ast_func_substring_before, // substring-before(left, right)
	9456	+ ast_func_substring_after, // substring-after(left, right)
	9457	+ ast_func_substring_2, // substring(left, right)
	9458	+ ast_func_substring_3, // substring(left, right, third)
	9459	+ ast_func_string_length_0, // string-length()
	9460	+ ast_func_string_length_1, // string-length(left)
	9461	+ ast_func_normalize_space_0, // normalize-space()
	9462	+ ast_func_normalize_space_1, // normalize-space(left)
	9463	+ ast_func_translate, // translate(left, right, third)
	9464	+ ast_func_boolean, // boolean(left)
	9465	+ ast_func_not, // not(left)
	9466	+ ast_func_true, // true()
	9467	+ ast_func_false, // false()
	9468	+ ast_func_lang, // lang(left)
	9469	+ ast_func_number_0, // number()
	9470	+ ast_func_number_1, // number(left)
	9471	+ ast_func_sum, // sum(left)
	9472	+ ast_func_floor, // floor(left)
	9473	+ ast_func_ceiling, // ceiling(left)
	9474	+ ast_func_round, // round(left)
	9475	+ ast_step, // process set left with step
	9476	+ ast_step_root, // select root node
	9477	+
	9478	+ ast_opt_translate_table, // translate(left, right, third) where right/third are constants
	9479	+ ast_opt_compare_attribute // @name = 'string'
	9480	+ };
	9481	+
	9482	+ enum axis_t
	9483	+ {
	9484	+ axis_ancestor,
	9485	+ axis_ancestor_or_self,
	9486	+ axis_attribute,
	9487	+ axis_child,
	9488	+ axis_descendant,
	9489	+ axis_descendant_or_self,
	9490	+ axis_following,
	9491	+ axis_following_sibling,
	9492	+ axis_namespace,
	9493	+ axis_parent,
	9494	+ axis_preceding,
	9495	+ axis_preceding_sibling,
	9496	+ axis_self
	9497	+ };
	9498	+
	9499	+ enum nodetest_t
	9500	+ {
	9501	+ nodetest_none,
	9502	+ nodetest_name,
	9503	+ nodetest_type_node,
	9504	+ nodetest_type_comment,
	9505	+ nodetest_type_pi,
	9506	+ nodetest_type_text,
	9507	+ nodetest_pi,
	9508	+ nodetest_all,
	9509	+ nodetest_all_in_namespace
	9510	+ };
	9511	+
	9512	+ enum predicate_t
	9513	+ {
	9514	+ predicate_default,
	9515	+ predicate_posinv,
	9516	+ predicate_constant,
	9517	+ predicate_constant_one
	9518	+ };
	9519	+
	9520	+ enum nodeset_eval_t
	9521	+ {
	9522	+ nodeset_eval_all,
	9523	+ nodeset_eval_any,
	9524	+ nodeset_eval_first
	9525	+ };
	9526	+
	9527	+ template <axis_t N> struct axis_to_type
	9528	+ {
	9529	+ static const axis_t axis;
	9530	+ };
	9531	+
	9532	+ template <axis_t N> const axis_t axis_to_type<N>::axis = N;
	9533	+
	9534	+ class xpath_ast_node
	9535	+ {
	9536	+ private:
	9537	+ // node type
	9538	+ char _type;
	9539	+ char _rettype;
	9540	+
	9541	+ // for ast_step
	9542	+ char _axis;
	9543	+
	9544	+ // for ast_step/ast_predicate/ast_filter
	9545	+ char _test;
	9546	+
	9547	+ // tree node structure
	9548	+ xpath_ast_node* _left;
	9549	+ xpath_ast_node* _right;
	9550	+ xpath_ast_node* _next;
	9551	+
	9552	+ union
	9553	+ {
	9554	+ // value for ast_string_constant
	9555	+ const char_t* string;
	9556	+ // value for ast_number_constant
	9557	+ double number;
	9558	+ // variable for ast_variable
	9559	+ xpath_variable* variable;
	9560	+ // node test for ast_step (node name/namespace/node type/pi target)
	9561	+ const char_t* nodetest;
	9562	+ // table for ast_opt_translate_table
	9563	+ const unsigned char* table;
	9564	+ } _data;
	9565	+
	9566	+ xpath_ast_node(const xpath_ast_node&);
	9567	+ xpath_ast_node& operator=(const xpath_ast_node&);
	9568	+
	9569	+ template <class Comp> static bool compare_eq(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const xpath_stack& stack, const Comp& comp)
	9570	+ {
	9571	+ xpath_value_type lt = lhs->rettype(), rt = rhs->rettype();
	9572	+
	9573	+ if (lt != xpath_type_node_set && rt != xpath_type_node_set)
	9574	+ {
	9575	+ if (lt == xpath_type_boolean \|\| rt == xpath_type_boolean)
	9576	+ return comp(lhs->eval_boolean(c, stack), rhs->eval_boolean(c, stack));
	9577	+ else if (lt == xpath_type_number \|\| rt == xpath_type_number)
	9578	+ return comp(lhs->eval_number(c, stack), rhs->eval_number(c, stack));
	9579	+ else if (lt == xpath_type_string \|\| rt == xpath_type_string)
	9580	+ {
	9581	+ xpath_allocator_capture cr(stack.result);
	9582	+
	9583	+ xpath_string ls = lhs->eval_string(c, stack);
	9584	+ xpath_string rs = rhs->eval_string(c, stack);
	9585	+
	9586	+ return comp(ls, rs);
	9587	+ }
	9588	+ }
	9589	+ else if (lt == xpath_type_node_set && rt == xpath_type_node_set)
	9590	+ {
	9591	+ xpath_allocator_capture cr(stack.result);
	9592	+
	9593	+ xpath_node_set_raw ls = lhs->eval_node_set(c, stack, nodeset_eval_all);
	9594	+ xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
	9595	+
	9596	+ for (const xpath_node* li = ls.begin(); li != ls.end(); ++li)
	9597	+ for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
	9598	+ {
	9599	+ xpath_allocator_capture cri(stack.result);
	9600	+
	9601	+ if (comp(string_value(li, stack.result), string_value(ri, stack.result)))
	9602	+ return true;
	9603	+ }
	9604	+
	9605	+ return false;
	9606	+ }
	9607	+ else
	9608	+ {
	9609	+ if (lt == xpath_type_node_set)
	9610	+ {
	9611	+ swap(lhs, rhs);
	9612	+ swap(lt, rt);
	9613	+ }
	9614	+
	9615	+ if (lt == xpath_type_boolean)
	9616	+ return comp(lhs->eval_boolean(c, stack), rhs->eval_boolean(c, stack));
	9617	+ else if (lt == xpath_type_number)
	9618	+ {
	9619	+ xpath_allocator_capture cr(stack.result);
	9620	+
	9621	+ double l = lhs->eval_number(c, stack);
	9622	+ xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
	9623	+
	9624	+ for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
	9625	+ {
	9626	+ xpath_allocator_capture cri(stack.result);
	9627	+
	9628	+ if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str())))
	9629	+ return true;
	9630	+ }
	9631	+
	9632	+ return false;
	9633	+ }
	9634	+ else if (lt == xpath_type_string)
	9635	+ {
	9636	+ xpath_allocator_capture cr(stack.result);
	9637	+
	9638	+ xpath_string l = lhs->eval_string(c, stack);
	9639	+ xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
	9640	+
	9641	+ for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
	9642	+ {
	9643	+ xpath_allocator_capture cri(stack.result);
	9644	+
	9645	+ if (comp(l, string_value(*ri, stack.result)))
	9646	+ return true;
	9647	+ }
	9648	+
	9649	+ return false;
	9650	+ }
	9651	+ }
	9652	+
	9653	+ assert(false && "Wrong types"); // unreachable
	9654	+ return false;
	9655	+ }
	9656	+
	9657	+ static bool eval_once(xpath_node_set::type_t type, nodeset_eval_t eval)
	9658	+ {
	9659	+ return type == xpath_node_set::type_sorted ? eval != nodeset_eval_all : eval == nodeset_eval_any;
	9660	+ }
	9661	+
	9662	+ template <class Comp> static bool compare_rel(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const xpath_stack& stack, const Comp& comp)
	9663	+ {
	9664	+ xpath_value_type lt = lhs->rettype(), rt = rhs->rettype();
	9665	+
	9666	+ if (lt != xpath_type_node_set && rt != xpath_type_node_set)
	9667	+ return comp(lhs->eval_number(c, stack), rhs->eval_number(c, stack));
	9668	+ else if (lt == xpath_type_node_set && rt == xpath_type_node_set)
	9669	+ {
	9670	+ xpath_allocator_capture cr(stack.result);
	9671	+
	9672	+ xpath_node_set_raw ls = lhs->eval_node_set(c, stack, nodeset_eval_all);
	9673	+ xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
	9674	+
	9675	+ for (const xpath_node* li = ls.begin(); li != ls.end(); ++li)
	9676	+ {
	9677	+ xpath_allocator_capture cri(stack.result);
	9678	+
	9679	+ double l = convert_string_to_number(string_value(*li, stack.result).c_str());
	9680	+
	9681	+ for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
	9682	+ {
	9683	+ xpath_allocator_capture crii(stack.result);
	9684	+
	9685	+ if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str())))
	9686	+ return true;
	9687	+ }
	9688	+ }
	9689	+
	9690	+ return false;
	9691	+ }
	9692	+ else if (lt != xpath_type_node_set && rt == xpath_type_node_set)
	9693	+ {
	9694	+ xpath_allocator_capture cr(stack.result);
	9695	+
	9696	+ double l = lhs->eval_number(c, stack);
	9697	+ xpath_node_set_raw rs = rhs->eval_node_set(c, stack, nodeset_eval_all);
	9698	+
	9699	+ for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
	9700	+ {
	9701	+ xpath_allocator_capture cri(stack.result);
	9702	+
	9703	+ if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str())))
	9704	+ return true;
	9705	+ }
	9706	+
	9707	+ return false;
	9708	+ }
	9709	+ else if (lt == xpath_type_node_set && rt != xpath_type_node_set)
	9710	+ {
	9711	+ xpath_allocator_capture cr(stack.result);
	9712	+
	9713	+ xpath_node_set_raw ls = lhs->eval_node_set(c, stack, nodeset_eval_all);
	9714	+ double r = rhs->eval_number(c, stack);
	9715	+
	9716	+ for (const xpath_node* li = ls.begin(); li != ls.end(); ++li)
	9717	+ {
	9718	+ xpath_allocator_capture cri(stack.result);
	9719	+
	9720	+ if (comp(convert_string_to_number(string_value(*li, stack.result).c_str()), r))
	9721	+ return true;
	9722	+ }
	9723	+
	9724	+ return false;
	9725	+ }
	9726	+ else
	9727	+ {
	9728	+ assert(false && "Wrong types"); // unreachable
	9729	+ return false;
	9730	+ }
	9731	+ }
	9732	+
	9733	+ static void apply_predicate_boolean(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack, bool once)
	9734	+ {
	9735	+ assert(ns.size() >= first);
	9736	+ assert(expr->rettype() != xpath_type_number);
	9737	+
	9738	+ size_t i = 1;
	9739	+ size_t size = ns.size() - first;
	9740	+
	9741	+ xpath_node* last = ns.begin() + first;
	9742	+
	9743	+ // remove_if... or well, sort of
	9744	+ for (xpath_node* it = last; it != ns.end(); ++it, ++i)
	9745	+ {
	9746	+ xpath_context c(*it, i, size);
	9747	+
	9748	+ if (expr->eval_boolean(c, stack))
	9749	+ {
	9750	+ last++ = it;
	9751	+
	9752	+ if (once) break;
	9753	+ }
	9754	+ }
	9755	+
	9756	+ ns.truncate(last);
	9757	+ }
	9758	+
	9759	+ static void apply_predicate_number(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack, bool once)
	9760	+ {
	9761	+ assert(ns.size() >= first);
	9762	+ assert(expr->rettype() == xpath_type_number);
	9763	+
	9764	+ size_t i = 1;
	9765	+ size_t size = ns.size() - first;
	9766	+
	9767	+ xpath_node* last = ns.begin() + first;
	9768	+
	9769	+ // remove_if... or well, sort of
	9770	+ for (xpath_node* it = last; it != ns.end(); ++it, ++i)
	9771	+ {
	9772	+ xpath_context c(*it, i, size);
	9773	+
	9774	+ if (expr->eval_number(c, stack) == static_cast<double>(i))
	9775	+ {
	9776	+ last++ = it;
	9777	+
	9778	+ if (once) break;
	9779	+ }
	9780	+ }
	9781	+
	9782	+ ns.truncate(last);
	9783	+ }
	9784	+
	9785	+ static void apply_predicate_number_const(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack)
	9786	+ {
	9787	+ assert(ns.size() >= first);
	9788	+ assert(expr->rettype() == xpath_type_number);
	9789	+
	9790	+ size_t size = ns.size() - first;
	9791	+
	9792	+ xpath_node* last = ns.begin() + first;
	9793	+
	9794	+ xpath_context c(xpath_node(), 1, size);
	9795	+
	9796	+ double er = expr->eval_number(c, stack);
	9797	+
	9798	+ if (er >= 1.0 && er <= static_cast<double>(size))
	9799	+ {
	9800	+ size_t eri = static_cast<size_t>(er);
	9801	+
	9802	+ if (er == static_cast<double>(eri))
	9803	+ {
	9804	+ xpath_node r = last[eri - 1];
	9805	+
	9806	+ *last++ = r;
	9807	+ }
	9808	+ }
	9809	+
	9810	+ ns.truncate(last);
	9811	+ }
	9812	+
	9813	+ void apply_predicate(xpath_node_set_raw& ns, size_t first, const xpath_stack& stack, bool once)
	9814	+ {
	9815	+ if (ns.size() == first) return;
	9816	+
	9817	+ assert(_type == ast_filter \|\| _type == ast_predicate);
	9818	+
	9819	+ if (_test == predicate_constant \|\| _test == predicate_constant_one)
	9820	+ apply_predicate_number_const(ns, first, _right, stack);
	9821	+ else if (_right->rettype() == xpath_type_number)
	9822	+ apply_predicate_number(ns, first, _right, stack, once);
	9823	+ else
	9824	+ apply_predicate_boolean(ns, first, _right, stack, once);
	9825	+ }
	9826	+
	9827	+ void apply_predicates(xpath_node_set_raw& ns, size_t first, const xpath_stack& stack, nodeset_eval_t eval)
	9828	+ {
	9829	+ if (ns.size() == first) return;
	9830	+
	9831	+ bool last_once = eval_once(ns.type(), eval);
	9832	+
	9833	+ for (xpath_ast_node* pred = _right; pred; pred = pred->_next)
	9834	+ pred->apply_predicate(ns, first, stack, !pred->_next && last_once);
	9835	+ }
	9836	+
	9837	+ bool step_push(xpath_node_set_raw& ns, xml_attribute_struct* a, xml_node_struct* parent, xpath_allocator* alloc)
	9838	+ {
	9839	+ assert(a);
	9840	+
	9841	+ const char_t* name = a->name ? a->name + 0 : PUGIXML_TEXT("");
	9842	+
	9843	+ switch (_test)
	9844	+ {
	9845	+ case nodetest_name:
	9846	+ if (strequal(name, _data.nodetest) && is_xpath_attribute(name))
	9847	+ {
	9848	+ ns.push_back(xpath_node(xml_attribute(a), xml_node(parent)), alloc);
	9849	+ return true;
	9850	+ }
	9851	+ break;
	9852	+
	9853	+ case nodetest_type_node:
	9854	+ case nodetest_all:
	9855	+ if (is_xpath_attribute(name))
	9856	+ {
	9857	+ ns.push_back(xpath_node(xml_attribute(a), xml_node(parent)), alloc);
	9858	+ return true;
	9859	+ }
	9860	+ break;
	9861	+
	9862	+ case nodetest_all_in_namespace:
	9863	+ if (starts_with(name, _data.nodetest) && is_xpath_attribute(name))
	9864	+ {
	9865	+ ns.push_back(xpath_node(xml_attribute(a), xml_node(parent)), alloc);
	9866	+ return true;
	9867	+ }
	9868	+ break;
	9869	+
	9870	+ default:
	9871	+ ;
	9872	+ }
	9873	+
	9874	+ return false;
	9875	+ }
	9876	+
	9877	+ bool step_push(xpath_node_set_raw& ns, xml_node_struct* n, xpath_allocator* alloc)
	9878	+ {
	9879	+ assert(n);
	9880	+
	9881	+ xml_node_type type = PUGI__NODETYPE(n);
	9882	+
	9883	+ switch (_test)
	9884	+ {
	9885	+ case nodetest_name:
	9886	+ if (type == node_element && n->name && strequal(n->name, _data.nodetest))
	9887	+ {
	9888	+ ns.push_back(xml_node(n), alloc);
	9889	+ return true;
	9890	+ }
	9891	+ break;
	9892	+
	9893	+ case nodetest_type_node:
	9894	+ ns.push_back(xml_node(n), alloc);
	9895	+ return true;
	9896	+
	9897	+ case nodetest_type_comment:
	9898	+ if (type == node_comment)
	9899	+ {
	9900	+ ns.push_back(xml_node(n), alloc);
	9901	+ return true;
	9902	+ }
	9903	+ break;
	9904	+
	9905	+ case nodetest_type_text:
	9906	+ if (type == node_pcdata \|\| type == node_cdata)
	9907	+ {
	9908	+ ns.push_back(xml_node(n), alloc);
	9909	+ return true;
	9910	+ }
	9911	+ break;
	9912	+
	9913	+ case nodetest_type_pi:
	9914	+ if (type == node_pi)
	9915	+ {
	9916	+ ns.push_back(xml_node(n), alloc);
	9917	+ return true;
	9918	+ }
	9919	+ break;
	9920	+
	9921	+ case nodetest_pi:
	9922	+ if (type == node_pi && n->name && strequal(n->name, _data.nodetest))
	9923	+ {
	9924	+ ns.push_back(xml_node(n), alloc);
	9925	+ return true;
	9926	+ }
	9927	+ break;
	9928	+
	9929	+ case nodetest_all:
	9930	+ if (type == node_element)
	9931	+ {
	9932	+ ns.push_back(xml_node(n), alloc);
	9933	+ return true;
	9934	+ }
	9935	+ break;
	9936	+
	9937	+ case nodetest_all_in_namespace:
	9938	+ if (type == node_element && n->name && starts_with(n->name, _data.nodetest))
	9939	+ {
	9940	+ ns.push_back(xml_node(n), alloc);
	9941	+ return true;
	9942	+ }
	9943	+ break;
	9944	+
	9945	+ default:
	9946	+ assert(false && "Unknown axis"); // unreachable
	9947	+ }
	9948	+
	9949	+ return false;
	9950	+ }
	9951	+
	9952	+ template <class T> void step_fill(xpath_node_set_raw& ns, xml_node_struct* n, xpath_allocator* alloc, bool once, T)
	9953	+ {
	9954	+ const axis_t axis = T::axis;
	9955	+
	9956	+ switch (axis)
	9957	+ {
	9958	+ case axis_attribute:
	9959	+ {
	9960	+ for (xml_attribute_struct* a = n->first_attribute; a; a = a->next_attribute)
	9961	+ if (step_push(ns, a, n, alloc) & once)
	9962	+ return;
	9963	+
	9964	+ break;
	9965	+ }
	9966	+
	9967	+ case axis_child:
	9968	+ {
	9969	+ for (xml_node_struct* c = n->first_child; c; c = c->next_sibling)
	9970	+ if (step_push(ns, c, alloc) & once)
	9971	+ return;
	9972	+
	9973	+ break;
	9974	+ }
	9975	+
	9976	+ case axis_descendant:
	9977	+ case axis_descendant_or_self:
	9978	+ {
	9979	+ if (axis == axis_descendant_or_self)
	9980	+ if (step_push(ns, n, alloc) & once)
	9981	+ return;
	9982	+
	9983	+ xml_node_struct* cur = n->first_child;
	9984	+
	9985	+ while (cur)
	9986	+ {
	9987	+ if (step_push(ns, cur, alloc) & once)
	9988	+ return;
	9989	+
	9990	+ if (cur->first_child)
	9991	+ cur = cur->first_child;
	9992	+ else
	9993	+ {
	9994	+ while (!cur->next_sibling)
	9995	+ {
	9996	+ cur = cur->parent;
	9997	+
	9998	+ if (cur == n) return;
	9999	+ }
	10000	+
	10001	+ cur = cur->next_sibling;
	10002	+ }
	10003	+ }
	10004	+
	10005	+ break;
	10006	+ }
	10007	+
	10008	+ case axis_following_sibling:
	10009	+ {
	10010	+ for (xml_node_struct* c = n->next_sibling; c; c = c->next_sibling)
	10011	+ if (step_push(ns, c, alloc) & once)
	10012	+ return;
	10013	+
	10014	+ break;
	10015	+ }
	10016	+
	10017	+ case axis_preceding_sibling:
	10018	+ {
	10019	+ for (xml_node_struct* c = n->prev_sibling_c; c->next_sibling; c = c->prev_sibling_c)
	10020	+ if (step_push(ns, c, alloc) & once)
	10021	+ return;
	10022	+
	10023	+ break;
	10024	+ }
	10025	+
	10026	+ case axis_following:
	10027	+ {
	10028	+ xml_node_struct* cur = n;
	10029	+
	10030	+ // exit from this node so that we don't include descendants
	10031	+ while (!cur->next_sibling)
	10032	+ {
	10033	+ cur = cur->parent;
	10034	+
	10035	+ if (!cur) return;
	10036	+ }
	10037	+
	10038	+ cur = cur->next_sibling;
	10039	+
	10040	+ while (cur)
	10041	+ {
	10042	+ if (step_push(ns, cur, alloc) & once)
	10043	+ return;
	10044	+
	10045	+ if (cur->first_child)
	10046	+ cur = cur->first_child;
	10047	+ else
	10048	+ {
	10049	+ while (!cur->next_sibling)
	10050	+ {
	10051	+ cur = cur->parent;
	10052	+
	10053	+ if (!cur) return;
	10054	+ }
	10055	+
	10056	+ cur = cur->next_sibling;
	10057	+ }
	10058	+ }
	10059	+
	10060	+ break;
	10061	+ }
	10062	+
	10063	+ case axis_preceding:
	10064	+ {
	10065	+ xml_node_struct* cur = n;
	10066	+
	10067	+ // exit from this node so that we don't include descendants
	10068	+ while (!cur->prev_sibling_c->next_sibling)
	10069	+ {
	10070	+ cur = cur->parent;
	10071	+
	10072	+ if (!cur) return;
	10073	+ }
	10074	+
	10075	+ cur = cur->prev_sibling_c;
	10076	+
	10077	+ while (cur)
	10078	+ {
	10079	+ if (cur->first_child)
	10080	+ cur = cur->first_child->prev_sibling_c;
	10081	+ else
	10082	+ {
	10083	+ // leaf node, can't be ancestor
	10084	+ if (step_push(ns, cur, alloc) & once)
	10085	+ return;
	10086	+
	10087	+ while (!cur->prev_sibling_c->next_sibling)
	10088	+ {
	10089	+ cur = cur->parent;
	10090	+
	10091	+ if (!cur) return;
	10092	+
	10093	+ if (!node_is_ancestor(cur, n))
	10094	+ if (step_push(ns, cur, alloc) & once)
	10095	+ return;
	10096	+ }
	10097	+
	10098	+ cur = cur->prev_sibling_c;
	10099	+ }
	10100	+ }
	10101	+
	10102	+ break;
	10103	+ }
	10104	+
	10105	+ case axis_ancestor:
	10106	+ case axis_ancestor_or_self:
	10107	+ {
	10108	+ if (axis == axis_ancestor_or_self)
	10109	+ if (step_push(ns, n, alloc) & once)
	10110	+ return;
	10111	+
	10112	+ xml_node_struct* cur = n->parent;
	10113	+
	10114	+ while (cur)
	10115	+ {
	10116	+ if (step_push(ns, cur, alloc) & once)
	10117	+ return;
	10118	+
	10119	+ cur = cur->parent;
	10120	+ }
	10121	+
	10122	+ break;
	10123	+ }
	10124	+
	10125	+ case axis_self:
	10126	+ {
	10127	+ step_push(ns, n, alloc);
	10128	+
	10129	+ break;
	10130	+ }
	10131	+
	10132	+ case axis_parent:
	10133	+ {
	10134	+ if (n->parent)
	10135	+ step_push(ns, n->parent, alloc);
	10136	+
	10137	+ break;
	10138	+ }
	10139	+
	10140	+ default:
	10141	+ assert(false && "Unimplemented axis"); // unreachable
	10142	+ }
	10143	+ }
	10144	+
	10145	+ template <class T> void step_fill(xpath_node_set_raw& ns, xml_attribute_struct* a, xml_node_struct* p, xpath_allocator* alloc, bool once, T v)
	10146	+ {
	10147	+ const axis_t axis = T::axis;
	10148	+
	10149	+ switch (axis)
	10150	+ {
	10151	+ case axis_ancestor:
	10152	+ case axis_ancestor_or_self:
	10153	+ {
	10154	+ if (axis == axis_ancestor_or_self && _test == nodetest_type_node) // reject attributes based on principal node type test
	10155	+ if (step_push(ns, a, p, alloc) & once)
	10156	+ return;
	10157	+
	10158	+ xml_node_struct* cur = p;
	10159	+
	10160	+ while (cur)
	10161	+ {
	10162	+ if (step_push(ns, cur, alloc) & once)
	10163	+ return;
	10164	+
	10165	+ cur = cur->parent;
	10166	+ }
	10167	+
	10168	+ break;
	10169	+ }
	10170	+
	10171	+ case axis_descendant_or_self:
	10172	+ case axis_self:
	10173	+ {
	10174	+ if (_test == nodetest_type_node) // reject attributes based on principal node type test
	10175	+ step_push(ns, a, p, alloc);
	10176	+
	10177	+ break;
	10178	+ }
	10179	+
	10180	+ case axis_following:
	10181	+ {
	10182	+ xml_node_struct* cur = p;
	10183	+
	10184	+ while (cur)
	10185	+ {
	10186	+ if (cur->first_child)
	10187	+ cur = cur->first_child;
	10188	+ else
	10189	+ {
	10190	+ while (!cur->next_sibling)
	10191	+ {
	10192	+ cur = cur->parent;
	10193	+
	10194	+ if (!cur) return;
	10195	+ }
	10196	+
	10197	+ cur = cur->next_sibling;
	10198	+ }
	10199	+
	10200	+ if (step_push(ns, cur, alloc) & once)
	10201	+ return;
	10202	+ }
	10203	+
	10204	+ break;
	10205	+ }
	10206	+
	10207	+ case axis_parent:
	10208	+ {
	10209	+ step_push(ns, p, alloc);
	10210	+
	10211	+ break;
	10212	+ }
	10213	+
	10214	+ case axis_preceding:
	10215	+ {
	10216	+ // preceding:: axis does not include attribute nodes and attribute ancestors (they are the same as parent's ancestors), so we can reuse node preceding
	10217	+ step_fill(ns, p, alloc, once, v);
	10218	+ break;
	10219	+ }
	10220	+
	10221	+ default:
	10222	+ assert(false && "Unimplemented axis"); // unreachable
	10223	+ }
	10224	+ }
	10225	+
	10226	+ template <class T> void step_fill(xpath_node_set_raw& ns, const xpath_node& xn, xpath_allocator* alloc, bool once, T v)
	10227	+ {
	10228	+ const axis_t axis = T::axis;
	10229	+ const bool axis_has_attributes = (axis == axis_ancestor \|\| axis == axis_ancestor_or_self \|\| axis == axis_descendant_or_self \|\| axis == axis_following \|\| axis == axis_parent \|\| axis == axis_preceding \|\| axis == axis_self);
	10230	+
	10231	+ if (xn.node())
	10232	+ step_fill(ns, xn.node().internal_object(), alloc, once, v);
	10233	+ else if (axis_has_attributes && xn.attribute() && xn.parent())
	10234	+ step_fill(ns, xn.attribute().internal_object(), xn.parent().internal_object(), alloc, once, v);
	10235	+ }
	10236	+
	10237	+ template <class T> xpath_node_set_raw step_do(const xpath_context& c, const xpath_stack& stack, nodeset_eval_t eval, T v)
	10238	+ {
	10239	+ const axis_t axis = T::axis;
	10240	+ const bool axis_reverse = (axis == axis_ancestor \|\| axis == axis_ancestor_or_self \|\| axis == axis_preceding \|\| axis == axis_preceding_sibling);
	10241	+ const xpath_node_set::type_t axis_type = axis_reverse ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted;
	10242	+
	10243	+ bool once =
	10244	+ (axis == axis_attribute && _test == nodetest_name) \|\|
	10245	+ (!_right && eval_once(axis_type, eval)) \|\|
	10246	+ // coverity[mixed_enums]
	10247	+ (_right && !_right->_next && _right->_test == predicate_constant_one);
	10248	+
	10249	+ xpath_node_set_raw ns;
	10250	+ ns.set_type(axis_type);
	10251	+
	10252	+ if (_left)
	10253	+ {
	10254	+ xpath_node_set_raw s = _left->eval_node_set(c, stack, nodeset_eval_all);
	10255	+
	10256	+ // self axis preserves the original order
	10257	+ if (axis == axis_self) ns.set_type(s.type());
	10258	+
	10259	+ for (const xpath_node* it = s.begin(); it != s.end(); ++it)
	10260	+ {
	10261	+ size_t size = ns.size();
	10262	+
	10263	+ // in general, all axes generate elements in a particular order, but there is no order guarantee if axis is applied to two nodes
	10264	+ if (axis != axis_self && size != 0) ns.set_type(xpath_node_set::type_unsorted);
	10265	+
	10266	+ step_fill(ns, *it, stack.result, once, v);
	10267	+ if (_right) apply_predicates(ns, size, stack, eval);
	10268	+ }
	10269	+ }
	10270	+ else
	10271	+ {
	10272	+ step_fill(ns, c.n, stack.result, once, v);
	10273	+ if (_right) apply_predicates(ns, 0, stack, eval);
	10274	+ }
	10275	+
	10276	+ // child, attribute and self axes always generate unique set of nodes
	10277	+ // for other axis, if the set stayed sorted, it stayed unique because the traversal algorithms do not visit the same node twice
	10278	+ if (axis != axis_child && axis != axis_attribute && axis != axis_self && ns.type() == xpath_node_set::type_unsorted)
	10279	+ ns.remove_duplicates(stack.temp);
	10280	+
	10281	+ return ns;
	10282	+ }
	10283	+
	10284	+ public:
	10285	+ xpath_ast_node(ast_type_t type, xpath_value_type rettype_, const char_t* value):
	10286	+ _type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
	10287	+ {
	10288	+ assert(type == ast_string_constant);
	10289	+ _data.string = value;
	10290	+ }
	10291	+
	10292	+ xpath_ast_node(ast_type_t type, xpath_value_type rettype_, double value):
	10293	+ _type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
	10294	+ {
	10295	+ assert(type == ast_number_constant);
	10296	+ _data.number = value;
	10297	+ }
	10298	+
	10299	+ xpath_ast_node(ast_type_t type, xpath_value_type rettype_, xpath_variable* value):
	10300	+ _type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
	10301	+ {
	10302	+ assert(type == ast_variable);
	10303	+ _data.variable = value;
	10304	+ }
	10305	+
	10306	+ xpath_ast_node(ast_type_t type, xpath_value_type rettype_, xpath_ast_node* left = 0, xpath_ast_node* right = 0):
	10307	+ _type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(left), _right(right), _next(0)
	10308	+ {
	10309	+ }
	10310	+
	10311	+ xpath_ast_node(ast_type_t type, xpath_ast_node* left, axis_t axis, nodetest_t test, const char_t* contents):
	10312	+ _type(static_cast<char>(type)), _rettype(xpath_type_node_set), _axis(static_cast<char>(axis)), _test(static_cast<char>(test)), _left(left), _right(0), _next(0)
	10313	+ {
	10314	+ assert(type == ast_step);
	10315	+ _data.nodetest = contents;
	10316	+ }
	10317	+
	10318	+ xpath_ast_node(ast_type_t type, xpath_ast_node* left, xpath_ast_node* right, predicate_t test):
	10319	+ _type(static_cast<char>(type)), _rettype(xpath_type_node_set), _axis(0), _test(static_cast<char>(test)), _left(left), _right(right), _next(0)
	10320	+ {
	10321	+ assert(type == ast_filter \|\| type == ast_predicate);
	10322	+ }
	10323	+
	10324	+ void set_next(xpath_ast_node* value)
	10325	+ {
	10326	+ _next = value;
	10327	+ }
	10328	+
	10329	+ void set_right(xpath_ast_node* value)
	10330	+ {
	10331	+ _right = value;
	10332	+ }
	10333	+
	10334	+ bool eval_boolean(const xpath_context& c, const xpath_stack& stack)
	10335	+ {
	10336	+ switch (_type)
	10337	+ {
	10338	+ case ast_op_or:
	10339	+ return _left->eval_boolean(c, stack) \|\| _right->eval_boolean(c, stack);
	10340	+
	10341	+ case ast_op_and:
	10342	+ return _left->eval_boolean(c, stack) && _right->eval_boolean(c, stack);
	10343	+
	10344	+ case ast_op_equal:
	10345	+ return compare_eq(_left, _right, c, stack, equal_to());
	10346	+
	10347	+ case ast_op_not_equal:
	10348	+ return compare_eq(_left, _right, c, stack, not_equal_to());
	10349	+
	10350	+ case ast_op_less:
	10351	+ return compare_rel(_left, _right, c, stack, less());
	10352	+
	10353	+ case ast_op_greater:
	10354	+ return compare_rel(_right, _left, c, stack, less());
	10355	+
	10356	+ case ast_op_less_or_equal:
	10357	+ return compare_rel(_left, _right, c, stack, less_equal());
	10358	+
	10359	+ case ast_op_greater_or_equal:
	10360	+ return compare_rel(_right, _left, c, stack, less_equal());
	10361	+
	10362	+ case ast_func_starts_with:
	10363	+ {
	10364	+ xpath_allocator_capture cr(stack.result);
	10365	+
	10366	+ xpath_string lr = _left->eval_string(c, stack);
	10367	+ xpath_string rr = _right->eval_string(c, stack);
	10368	+
	10369	+ return starts_with(lr.c_str(), rr.c_str());
	10370	+ }
	10371	+
	10372	+ case ast_func_contains:
	10373	+ {
	10374	+ xpath_allocator_capture cr(stack.result);
	10375	+
	10376	+ xpath_string lr = _left->eval_string(c, stack);
	10377	+ xpath_string rr = _right->eval_string(c, stack);
	10378	+
	10379	+ return find_substring(lr.c_str(), rr.c_str()) != 0;
	10380	+ }
	10381	+
	10382	+ case ast_func_boolean:
	10383	+ return _left->eval_boolean(c, stack);
	10384	+
	10385	+ case ast_func_not:
	10386	+ return !_left->eval_boolean(c, stack);
	10387	+
	10388	+ case ast_func_true:
	10389	+ return true;
	10390	+
	10391	+ case ast_func_false:
	10392	+ return false;
	10393	+
	10394	+ case ast_func_lang:
	10395	+ {
	10396	+ if (c.n.attribute()) return false;
	10397	+
	10398	+ xpath_allocator_capture cr(stack.result);
	10399	+
	10400	+ xpath_string lang = _left->eval_string(c, stack);
	10401	+
	10402	+ for (xml_node n = c.n.node(); n; n = n.parent())
	10403	+ {
	10404	+ xml_attribute a = n.attribute(PUGIXML_TEXT("xml:lang"));
	10405	+
	10406	+ if (a)
	10407	+ {
	10408	+ const char_t* value = a.value();
	10409	+
	10410	+ // strnicmp / strncasecmp is not portable
	10411	+ for (const char_t* lit = lang.c_str(); *lit; ++lit)
	10412	+ {
	10413	+ if (tolower_ascii(lit) != tolower_ascii(value)) return false;
	10414	+ ++value;
	10415	+ }
	10416	+
	10417	+ return value == 0 \|\| value == '-';
	10418	+ }
	10419	+ }
	10420	+
	10421	+ return false;
	10422	+ }
	10423	+
	10424	+ case ast_opt_compare_attribute:
	10425	+ {
	10426	+ const char_t* value = (_right->_type == ast_string_constant) ? _right->_data.string : _right->_data.variable->get_string();
	10427	+
	10428	+ xml_attribute attr = c.n.node().attribute(_left->_data.nodetest);
	10429	+
	10430	+ return attr && strequal(attr.value(), value) && is_xpath_attribute(attr.name());
	10431	+ }
	10432	+
	10433	+ case ast_variable:
	10434	+ {
	10435	+ assert(_rettype == _data.variable->type());
	10436	+
	10437	+ if (_rettype == xpath_type_boolean)
	10438	+ return _data.variable->get_boolean();
	10439	+
	10440	+ // variable needs to be converted to the correct type, this is handled by the fallthrough block below
	10441	+ break;
	10442	+ }
	10443	+
	10444	+ default:
	10445	+ ;
	10446	+ }
	10447	+
	10448	+ // none of the ast types that return the value directly matched, we need to perform type conversion
	10449	+ switch (_rettype)
	10450	+ {
	10451	+ case xpath_type_number:
	10452	+ return convert_number_to_boolean(eval_number(c, stack));
	10453	+
	10454	+ case xpath_type_string:
	10455	+ {
	10456	+ xpath_allocator_capture cr(stack.result);
	10457	+
	10458	+ return !eval_string(c, stack).empty();
	10459	+ }
	10460	+
	10461	+ case xpath_type_node_set:
	10462	+ {
	10463	+ xpath_allocator_capture cr(stack.result);
	10464	+
	10465	+ return !eval_node_set(c, stack, nodeset_eval_any).empty();
	10466	+ }
	10467	+
	10468	+ default:
	10469	+ assert(false && "Wrong expression for return type boolean"); // unreachable
	10470	+ return false;
	10471	+ }
	10472	+ }
	10473	+
	10474	+ double eval_number(const xpath_context& c, const xpath_stack& stack)
	10475	+ {
	10476	+ switch (_type)
	10477	+ {
	10478	+ case ast_op_add:
	10479	+ return _left->eval_number(c, stack) + _right->eval_number(c, stack);
	10480	+
	10481	+ case ast_op_subtract:
	10482	+ return _left->eval_number(c, stack) - _right->eval_number(c, stack);
	10483	+
	10484	+ case ast_op_multiply:
	10485	+ return _left->eval_number(c, stack) * _right->eval_number(c, stack);
	10486	+
	10487	+ case ast_op_divide:
	10488	+ return _left->eval_number(c, stack) / _right->eval_number(c, stack);
	10489	+
	10490	+ case ast_op_mod:
	10491	+ return fmod(_left->eval_number(c, stack), _right->eval_number(c, stack));
	10492	+
	10493	+ case ast_op_negate:
	10494	+ return -_left->eval_number(c, stack);
	10495	+
	10496	+ case ast_number_constant:
	10497	+ return _data.number;
	10498	+
	10499	+ case ast_func_last:
	10500	+ return static_cast<double>(c.size);
	10501	+
	10502	+ case ast_func_position:
	10503	+ return static_cast<double>(c.position);
	10504	+
	10505	+ case ast_func_count:
	10506	+ {
	10507	+ xpath_allocator_capture cr(stack.result);
	10508	+
	10509	+ return static_cast<double>(_left->eval_node_set(c, stack, nodeset_eval_all).size());
	10510	+ }
	10511	+
	10512	+ case ast_func_string_length_0:
	10513	+ {
	10514	+ xpath_allocator_capture cr(stack.result);
	10515	+
	10516	+ return static_cast<double>(string_value(c.n, stack.result).length());
	10517	+ }
	10518	+
	10519	+ case ast_func_string_length_1:
	10520	+ {
	10521	+ xpath_allocator_capture cr(stack.result);
	10522	+
	10523	+ return static_cast<double>(_left->eval_string(c, stack).length());
	10524	+ }
	10525	+
	10526	+ case ast_func_number_0:
	10527	+ {
	10528	+ xpath_allocator_capture cr(stack.result);
	10529	+
	10530	+ return convert_string_to_number(string_value(c.n, stack.result).c_str());
	10531	+ }
	10532	+
	10533	+ case ast_func_number_1:
	10534	+ return _left->eval_number(c, stack);
	10535	+
	10536	+ case ast_func_sum:
	10537	+ {
	10538	+ xpath_allocator_capture cr(stack.result);
	10539	+
	10540	+ double r = 0;
	10541	+
	10542	+ xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_all);
	10543	+
	10544	+ for (const xpath_node* it = ns.begin(); it != ns.end(); ++it)
	10545	+ {
	10546	+ xpath_allocator_capture cri(stack.result);
	10547	+
	10548	+ r += convert_string_to_number(string_value(*it, stack.result).c_str());
	10549	+ }
	10550	+
	10551	+ return r;
	10552	+ }
	10553	+
	10554	+ case ast_func_floor:
	10555	+ {
	10556	+ double r = _left->eval_number(c, stack);
	10557	+
	10558	+ return r == r ? floor(r) : r;
	10559	+ }
	10560	+
	10561	+ case ast_func_ceiling:
	10562	+ {
	10563	+ double r = _left->eval_number(c, stack);
	10564	+
	10565	+ return r == r ? ceil(r) : r;
	10566	+ }
	10567	+
	10568	+ case ast_func_round:
	10569	+ return round_nearest_nzero(_left->eval_number(c, stack));
	10570	+
	10571	+ case ast_variable:
	10572	+ {
	10573	+ assert(_rettype == _data.variable->type());
	10574	+
	10575	+ if (_rettype == xpath_type_number)
	10576	+ return _data.variable->get_number();
	10577	+
	10578	+ // variable needs to be converted to the correct type, this is handled by the fallthrough block below
	10579	+ break;
	10580	+ }
	10581	+
	10582	+ default:
	10583	+ ;
	10584	+ }
	10585	+
	10586	+ // none of the ast types that return the value directly matched, we need to perform type conversion
	10587	+ switch (_rettype)
	10588	+ {
	10589	+ case xpath_type_boolean:
	10590	+ return eval_boolean(c, stack) ? 1 : 0;
	10591	+
	10592	+ case xpath_type_string:
	10593	+ {
	10594	+ xpath_allocator_capture cr(stack.result);
	10595	+
	10596	+ return convert_string_to_number(eval_string(c, stack).c_str());
	10597	+ }
	10598	+
	10599	+ case xpath_type_node_set:
	10600	+ {
	10601	+ xpath_allocator_capture cr(stack.result);
	10602	+
	10603	+ return convert_string_to_number(eval_string(c, stack).c_str());
	10604	+ }
	10605	+
	10606	+ default:
	10607	+ assert(false && "Wrong expression for return type number"); // unreachable
	10608	+ return 0;
	10609	+ }
	10610	+ }
	10611	+
	10612	+ xpath_string eval_string_concat(const xpath_context& c, const xpath_stack& stack)
	10613	+ {
	10614	+ assert(_type == ast_func_concat);
	10615	+
	10616	+ xpath_allocator_capture ct(stack.temp);
	10617	+
	10618	+ // count the string number
	10619	+ size_t count = 1;
	10620	+ for (xpath_ast_node* nc = _right; nc; nc = nc->_next) count++;
	10621	+
	10622	+ // allocate a buffer for temporary string objects
	10623	+ xpath_string* buffer = static_cast<xpath_string>(stack.temp->allocate(count sizeof(xpath_string)));
	10624	+ if (!buffer) return xpath_string();
	10625	+
	10626	+ // evaluate all strings to temporary stack
	10627	+ xpath_stack swapped_stack = {stack.temp, stack.result};
	10628	+
	10629	+ buffer[0] = _left->eval_string(c, swapped_stack);
	10630	+
	10631	+ size_t pos = 1;
	10632	+ for (xpath_ast_node* n = _right; n; n = n->_next, ++pos) buffer[pos] = n->eval_string(c, swapped_stack);
	10633	+ assert(pos == count);
	10634	+
	10635	+ // get total length
	10636	+ size_t length = 0;
	10637	+ for (size_t i = 0; i < count; ++i) length += buffer[i].length();
	10638	+
	10639	+ // create final string
	10640	+ char_t* result = static_cast<char_t>(stack.result->allocate((length + 1) sizeof(char_t)));
	10641	+ if (!result) return xpath_string();
	10642	+
	10643	+ char_t* ri = result;
	10644	+
	10645	+ for (size_t j = 0; j < count; ++j)
	10646	+ for (const char_t* bi = buffer[j].c_str(); *bi; ++bi)
	10647	+ ri++ = bi;
	10648	+
	10649	+ *ri = 0;
	10650	+
	10651	+ return xpath_string::from_heap_preallocated(result, ri);
	10652	+ }
	10653	+
	10654	+ xpath_string eval_string(const xpath_context& c, const xpath_stack& stack)
	10655	+ {
	10656	+ switch (_type)
	10657	+ {
	10658	+ case ast_string_constant:
	10659	+ return xpath_string::from_const(_data.string);
	10660	+
	10661	+ case ast_func_local_name_0:
	10662	+ {
	10663	+ xpath_node na = c.n;
	10664	+
	10665	+ return xpath_string::from_const(local_name(na));
	10666	+ }
	10667	+
	10668	+ case ast_func_local_name_1:
	10669	+ {
	10670	+ xpath_allocator_capture cr(stack.result);
	10671	+
	10672	+ xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_first);
	10673	+ xpath_node na = ns.first();
	10674	+
	10675	+ return xpath_string::from_const(local_name(na));
	10676	+ }
	10677	+
	10678	+ case ast_func_name_0:
	10679	+ {
	10680	+ xpath_node na = c.n;
	10681	+
	10682	+ return xpath_string::from_const(qualified_name(na));
	10683	+ }
	10684	+
	10685	+ case ast_func_name_1:
	10686	+ {
	10687	+ xpath_allocator_capture cr(stack.result);
	10688	+
	10689	+ xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_first);
	10690	+ xpath_node na = ns.first();
	10691	+
	10692	+ return xpath_string::from_const(qualified_name(na));
	10693	+ }
	10694	+
	10695	+ case ast_func_namespace_uri_0:
	10696	+ {
	10697	+ xpath_node na = c.n;
	10698	+
	10699	+ return xpath_string::from_const(namespace_uri(na));
	10700	+ }
	10701	+
	10702	+ case ast_func_namespace_uri_1:
	10703	+ {
	10704	+ xpath_allocator_capture cr(stack.result);
	10705	+
	10706	+ xpath_node_set_raw ns = _left->eval_node_set(c, stack, nodeset_eval_first);
	10707	+ xpath_node na = ns.first();
	10708	+
	10709	+ return xpath_string::from_const(namespace_uri(na));
	10710	+ }
	10711	+
	10712	+ case ast_func_string_0:
	10713	+ return string_value(c.n, stack.result);
	10714	+
	10715	+ case ast_func_string_1:
	10716	+ return _left->eval_string(c, stack);
	10717	+
	10718	+ case ast_func_concat:
	10719	+ return eval_string_concat(c, stack);
	10720	+
	10721	+ case ast_func_substring_before:
	10722	+ {
	10723	+ xpath_allocator_capture cr(stack.temp);
	10724	+
	10725	+ xpath_stack swapped_stack = {stack.temp, stack.result};
	10726	+
	10727	+ xpath_string s = _left->eval_string(c, swapped_stack);
	10728	+ xpath_string p = _right->eval_string(c, swapped_stack);
	10729	+
	10730	+ const char_t* pos = find_substring(s.c_str(), p.c_str());
	10731	+
	10732	+ return pos ? xpath_string::from_heap(s.c_str(), pos, stack.result) : xpath_string();
	10733	+ }
	10734	+
	10735	+ case ast_func_substring_after:
	10736	+ {
	10737	+ xpath_allocator_capture cr(stack.temp);
	10738	+
	10739	+ xpath_stack swapped_stack = {stack.temp, stack.result};
	10740	+
	10741	+ xpath_string s = _left->eval_string(c, swapped_stack);
	10742	+ xpath_string p = _right->eval_string(c, swapped_stack);
	10743	+
	10744	+ const char_t* pos = find_substring(s.c_str(), p.c_str());
	10745	+ if (!pos) return xpath_string();
	10746	+
	10747	+ const char_t* rbegin = pos + p.length();
	10748	+ const char_t* rend = s.c_str() + s.length();
	10749	+
	10750	+ return s.uses_heap() ? xpath_string::from_heap(rbegin, rend, stack.result) : xpath_string::from_const(rbegin);
	10751	+ }
	10752	+
	10753	+ case ast_func_substring_2:
	10754	+ {
	10755	+ xpath_allocator_capture cr(stack.temp);
	10756	+
	10757	+ xpath_stack swapped_stack = {stack.temp, stack.result};
	10758	+
	10759	+ xpath_string s = _left->eval_string(c, swapped_stack);
	10760	+ size_t s_length = s.length();
	10761	+
	10762	+ double first = round_nearest(_right->eval_number(c, stack));
	10763	+
	10764	+ if (is_nan(first)) return xpath_string(); // NaN
	10765	+ else if (first >= static_cast<double>(s_length + 1)) return xpath_string();
	10766	+
	10767	+ size_t pos = first < 1 ? 1 : static_cast<size_t>(first);
	10768	+ assert(1 <= pos && pos <= s_length + 1);
	10769	+
	10770	+ const char_t* rbegin = s.c_str() + (pos - 1);
	10771	+ const char_t* rend = s.c_str() + s.length();
	10772	+
	10773	+ return s.uses_heap() ? xpath_string::from_heap(rbegin, rend, stack.result) : xpath_string::from_const(rbegin);
	10774	+ }
	10775	+
	10776	+ case ast_func_substring_3:
	10777	+ {
	10778	+ xpath_allocator_capture cr(stack.temp);
	10779	+
	10780	+ xpath_stack swapped_stack = {stack.temp, stack.result};
	10781	+
	10782	+ xpath_string s = _left->eval_string(c, swapped_stack);
	10783	+ size_t s_length = s.length();
	10784	+
	10785	+ double first = round_nearest(_right->eval_number(c, stack));
	10786	+ double last = first + round_nearest(_right->_next->eval_number(c, stack));
	10787	+
	10788	+ if (is_nan(first) \|\| is_nan(last)) return xpath_string();
	10789	+ else if (first >= static_cast<double>(s_length + 1)) return xpath_string();
	10790	+ else if (first >= last) return xpath_string();
	10791	+ else if (last < 1) return xpath_string();
	10792	+
	10793	+ size_t pos = first < 1 ? 1 : static_cast<size_t>(first);
	10794	+ size_t end = last >= static_cast<double>(s_length + 1) ? s_length + 1 : static_cast<size_t>(last);
	10795	+
	10796	+ assert(1 <= pos && pos <= end && end <= s_length + 1);
	10797	+ const char_t* rbegin = s.c_str() + (pos - 1);
	10798	+ const char_t* rend = s.c_str() + (end - 1);
	10799	+
	10800	+ return (end == s_length + 1 && !s.uses_heap()) ? xpath_string::from_const(rbegin) : xpath_string::from_heap(rbegin, rend, stack.result);
	10801	+ }
	10802	+
	10803	+ case ast_func_normalize_space_0:
	10804	+ {
	10805	+ xpath_string s = string_value(c.n, stack.result);
	10806	+
	10807	+ char_t* begin = s.data(stack.result);
	10808	+ if (!begin) return xpath_string();
	10809	+
	10810	+ char_t* end = normalize_space(begin);
	10811	+
	10812	+ return xpath_string::from_heap_preallocated(begin, end);
	10813	+ }
	10814	+
	10815	+ case ast_func_normalize_space_1:
	10816	+ {
	10817	+ xpath_string s = _left->eval_string(c, stack);
	10818	+
	10819	+ char_t* begin = s.data(stack.result);
	10820	+ if (!begin) return xpath_string();
	10821	+
	10822	+ char_t* end = normalize_space(begin);
	10823	+
	10824	+ return xpath_string::from_heap_preallocated(begin, end);
	10825	+ }
	10826	+
	10827	+ case ast_func_translate:
	10828	+ {
	10829	+ xpath_allocator_capture cr(stack.temp);
	10830	+
	10831	+ xpath_stack swapped_stack = {stack.temp, stack.result};
	10832	+
	10833	+ xpath_string s = _left->eval_string(c, stack);
	10834	+ xpath_string from = _right->eval_string(c, swapped_stack);
	10835	+ xpath_string to = _right->_next->eval_string(c, swapped_stack);
	10836	+
	10837	+ char_t* begin = s.data(stack.result);
	10838	+ if (!begin) return xpath_string();
	10839	+
	10840	+ char_t* end = translate(begin, from.c_str(), to.c_str(), to.length());
	10841	+
	10842	+ return xpath_string::from_heap_preallocated(begin, end);
	10843	+ }
	10844	+
	10845	+ case ast_opt_translate_table:
	10846	+ {
	10847	+ xpath_string s = _left->eval_string(c, stack);
	10848	+
	10849	+ char_t* begin = s.data(stack.result);
	10850	+ if (!begin) return xpath_string();
	10851	+
	10852	+ char_t* end = translate_table(begin, _data.table);
	10853	+
	10854	+ return xpath_string::from_heap_preallocated(begin, end);
	10855	+ }
	10856	+
	10857	+ case ast_variable:
	10858	+ {
	10859	+ assert(_rettype == _data.variable->type());
	10860	+
	10861	+ if (_rettype == xpath_type_string)
	10862	+ return xpath_string::from_const(_data.variable->get_string());
	10863	+
	10864	+ // variable needs to be converted to the correct type, this is handled by the fallthrough block below
	10865	+ break;
	10866	+ }
	10867	+
	10868	+ default:
	10869	+ ;
	10870	+ }
	10871	+
	10872	+ // none of the ast types that return the value directly matched, we need to perform type conversion
	10873	+ switch (_rettype)
	10874	+ {
	10875	+ case xpath_type_boolean:
	10876	+ return xpath_string::from_const(eval_boolean(c, stack) ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false"));
	10877	+
	10878	+ case xpath_type_number:
	10879	+ return convert_number_to_string(eval_number(c, stack), stack.result);
	10880	+
	10881	+ case xpath_type_node_set:
	10882	+ {
	10883	+ xpath_allocator_capture cr(stack.temp);
	10884	+
	10885	+ xpath_stack swapped_stack = {stack.temp, stack.result};
	10886	+
	10887	+ xpath_node_set_raw ns = eval_node_set(c, swapped_stack, nodeset_eval_first);
	10888	+ return ns.empty() ? xpath_string() : string_value(ns.first(), stack.result);
	10889	+ }
	10890	+
	10891	+ default:
	10892	+ assert(false && "Wrong expression for return type string"); // unreachable
	10893	+ return xpath_string();
	10894	+ }
	10895	+ }
	10896	+
	10897	+ xpath_node_set_raw eval_node_set(const xpath_context& c, const xpath_stack& stack, nodeset_eval_t eval)
	10898	+ {
	10899	+ switch (_type)
	10900	+ {
	10901	+ case ast_op_union:
	10902	+ {
	10903	+ xpath_allocator_capture cr(stack.temp);
	10904	+
	10905	+ xpath_stack swapped_stack = {stack.temp, stack.result};
	10906	+
	10907	+ xpath_node_set_raw ls = _left->eval_node_set(c, stack, eval);
	10908	+ xpath_node_set_raw rs = _right->eval_node_set(c, swapped_stack, eval);
	10909	+
	10910	+ // we can optimize merging two sorted sets, but this is a very rare operation, so don't bother
	10911	+ ls.set_type(xpath_node_set::type_unsorted);
	10912	+
	10913	+ ls.append(rs.begin(), rs.end(), stack.result);
	10914	+ ls.remove_duplicates(stack.temp);
	10915	+
	10916	+ return ls;
	10917	+ }
	10918	+
	10919	+ case ast_filter:
	10920	+ {
	10921	+ xpath_node_set_raw set = _left->eval_node_set(c, stack, _test == predicate_constant_one ? nodeset_eval_first : nodeset_eval_all);
	10922	+
	10923	+ // either expression is a number or it contains position() call; sort by document order
	10924	+ if (_test != predicate_posinv) set.sort_do();
	10925	+
	10926	+ bool once = eval_once(set.type(), eval);
	10927	+
	10928	+ apply_predicate(set, 0, stack, once);
	10929	+
	10930	+ return set;
	10931	+ }
	10932	+
	10933	+ case ast_func_id:
	10934	+ return xpath_node_set_raw();
	10935	+
	10936	+ case ast_step:
	10937	+ {
	10938	+ switch (_axis)
	10939	+ {
	10940	+ case axis_ancestor:
	10941	+ return step_do(c, stack, eval, axis_to_type<axis_ancestor>());
	10942	+
	10943	+ case axis_ancestor_or_self:
	10944	+ return step_do(c, stack, eval, axis_to_type<axis_ancestor_or_self>());
	10945	+
	10946	+ case axis_attribute:
	10947	+ return step_do(c, stack, eval, axis_to_type<axis_attribute>());
	10948	+
	10949	+ case axis_child:
	10950	+ return step_do(c, stack, eval, axis_to_type<axis_child>());
	10951	+
	10952	+ case axis_descendant:
	10953	+ return step_do(c, stack, eval, axis_to_type<axis_descendant>());
	10954	+
	10955	+ case axis_descendant_or_self:
	10956	+ return step_do(c, stack, eval, axis_to_type<axis_descendant_or_self>());
	10957	+
	10958	+ case axis_following:
	10959	+ return step_do(c, stack, eval, axis_to_type<axis_following>());
	10960	+
	10961	+ case axis_following_sibling:
	10962	+ return step_do(c, stack, eval, axis_to_type<axis_following_sibling>());
	10963	+
	10964	+ case axis_namespace:
	10965	+ // namespaced axis is not supported
	10966	+ return xpath_node_set_raw();
	10967	+
	10968	+ case axis_parent:
	10969	+ return step_do(c, stack, eval, axis_to_type<axis_parent>());
	10970	+
	10971	+ case axis_preceding:
	10972	+ return step_do(c, stack, eval, axis_to_type<axis_preceding>());
	10973	+
	10974	+ case axis_preceding_sibling:
	10975	+ return step_do(c, stack, eval, axis_to_type<axis_preceding_sibling>());
	10976	+
	10977	+ case axis_self:
	10978	+ return step_do(c, stack, eval, axis_to_type<axis_self>());
	10979	+
	10980	+ default:
	10981	+ assert(false && "Unknown axis"); // unreachable
	10982	+ return xpath_node_set_raw();
	10983	+ }
	10984	+ }
	10985	+
	10986	+ case ast_step_root:
	10987	+ {
	10988	+ assert(!_right); // root step can't have any predicates
	10989	+
	10990	+ xpath_node_set_raw ns;
	10991	+
	10992	+ ns.set_type(xpath_node_set::type_sorted);
	10993	+
	10994	+ if (c.n.node()) ns.push_back(c.n.node().root(), stack.result);
	10995	+ else if (c.n.attribute()) ns.push_back(c.n.parent().root(), stack.result);
	10996	+
	10997	+ return ns;
	10998	+ }
	10999	+
	11000	+ case ast_variable:
	11001	+ {
	11002	+ assert(_rettype == _data.variable->type());
	11003	+
	11004	+ if (_rettype == xpath_type_node_set)
	11005	+ {
	11006	+ const xpath_node_set& s = _data.variable->get_node_set();
	11007	+
	11008	+ xpath_node_set_raw ns;
	11009	+
	11010	+ ns.set_type(s.type());
	11011	+ ns.append(s.begin(), s.end(), stack.result);
	11012	+
	11013	+ return ns;
	11014	+ }
	11015	+
	11016	+ // variable needs to be converted to the correct type, this is handled by the fallthrough block below
	11017	+ break;
	11018	+ }
	11019	+
	11020	+ default:
	11021	+ ;
	11022	+ }
	11023	+
	11024	+ // none of the ast types that return the value directly matched, but conversions to node set are invalid
	11025	+ assert(false && "Wrong expression for return type node set"); // unreachable
	11026	+ return xpath_node_set_raw();
	11027	+ }
	11028	+
	11029	+ void optimize(xpath_allocator* alloc)
	11030	+ {
	11031	+ if (_left)
	11032	+ _left->optimize(alloc);
	11033	+
	11034	+ if (_right)
	11035	+ _right->optimize(alloc);
	11036	+
	11037	+ if (_next)
	11038	+ _next->optimize(alloc);
	11039	+
	11040	+ // coverity[var_deref_model]
	11041	+ optimize_self(alloc);
	11042	+ }
	11043	+
	11044	+ void optimize_self(xpath_allocator* alloc)
	11045	+ {
	11046	+ // Rewrite [position()=expr] with [expr]
	11047	+ // Note that this step has to go before classification to recognize [position()=1]
	11048	+ if ((_type == ast_filter \|\| _type == ast_predicate) &&
	11049	+ _right && // workaround for clang static analyzer (_right is never null for ast_filter/ast_predicate)
	11050	+ _right->_type == ast_op_equal && _right->_left->_type == ast_func_position && _right->_right->_rettype == xpath_type_number)
	11051	+ {
	11052	+ _right = _right->_right;
	11053	+ }
	11054	+
	11055	+ // Classify filter/predicate ops to perform various optimizations during evaluation
	11056	+ if ((_type == ast_filter \|\| _type == ast_predicate) && _right) // workaround for clang static analyzer (_right is never null for ast_filter/ast_predicate)
	11057	+ {
	11058	+ assert(_test == predicate_default);
	11059	+
	11060	+ if (_right->_type == ast_number_constant && _right->_data.number == 1.0)
	11061	+ _test = predicate_constant_one;
	11062	+ else if (_right->_rettype == xpath_type_number && (_right->_type == ast_number_constant \|\| _right->_type == ast_variable \|\| _right->_type == ast_func_last))
	11063	+ _test = predicate_constant;
	11064	+ else if (_right->_rettype != xpath_type_number && _right->is_posinv_expr())
	11065	+ _test = predicate_posinv;
	11066	+ }
	11067	+
	11068	+ // Rewrite descendant-or-self::node()/child::foo with descendant::foo
	11069	+ // The former is a full form of //foo, the latter is much faster since it executes the node test immediately
	11070	+ // Do a similar kind of rewrite for self/descendant/descendant-or-self axes
	11071	+ // Note that we only rewrite positionally invariant steps (//foo[1] != /descendant::foo[1])
	11072	+ if (_type == ast_step && (_axis == axis_child \|\| _axis == axis_self \|\| _axis == axis_descendant \|\| _axis == axis_descendant_or_self) &&
	11073	+ _left && _left->_type == ast_step && _left->_axis == axis_descendant_or_self && _left->_test == nodetest_type_node && !_left->_right &&
	11074	+ is_posinv_step())
	11075	+ {
	11076	+ if (_axis == axis_child \|\| _axis == axis_descendant)
	11077	+ _axis = axis_descendant;
	11078	+ else
	11079	+ _axis = axis_descendant_or_self;
	11080	+
	11081	+ _left = _left->_left;
	11082	+ }
	11083	+
	11084	+ // Use optimized lookup table implementation for translate() with constant arguments
	11085	+ if (_type == ast_func_translate &&
	11086	+ _right && // workaround for clang static analyzer (_right is never null for ast_func_translate)
	11087	+ _right->_type == ast_string_constant && _right->_next->_type == ast_string_constant)
	11088	+ {
	11089	+ unsigned char* table = translate_table_generate(alloc, _right->_data.string, _right->_next->_data.string);
	11090	+
	11091	+ if (table)
	11092	+ {
	11093	+ _type = ast_opt_translate_table;
	11094	+ _data.table = table;
	11095	+ }
	11096	+ }
	11097	+
	11098	+ // Use optimized path for @attr = 'value' or @attr = $value
	11099	+ if (_type == ast_op_equal &&
	11100	+ _left && _right && // workaround for clang static analyzer and Coverity (_left and _right are never null for ast_op_equal)
	11101	+ // coverity[mixed_enums]
	11102	+ _left->_type == ast_step && _left->_axis == axis_attribute && _left->_test == nodetest_name && !_left->_left && !_left->_right &&
	11103	+ (_right->_type == ast_string_constant \|\| (_right->_type == ast_variable && _right->_rettype == xpath_type_string)))
	11104	+ {
	11105	+ _type = ast_opt_compare_attribute;
	11106	+ }
	11107	+ }
	11108	+
	11109	+ bool is_posinv_expr() const
	11110	+ {
	11111	+ switch (_type)
	11112	+ {
	11113	+ case ast_func_position:
	11114	+ case ast_func_last:
	11115	+ return false;
	11116	+
	11117	+ case ast_string_constant:
	11118	+ case ast_number_constant:
	11119	+ case ast_variable:
	11120	+ return true;
	11121	+
	11122	+ case ast_step:
	11123	+ case ast_step_root:
	11124	+ return true;
	11125	+
	11126	+ case ast_predicate:
	11127	+ case ast_filter:
	11128	+ return true;
	11129	+
	11130	+ default:
	11131	+ if (_left && !_left->is_posinv_expr()) return false;
	11132	+
	11133	+ for (xpath_ast_node* n = _right; n; n = n->_next)
	11134	+ if (!n->is_posinv_expr()) return false;
	11135	+
	11136	+ return true;
	11137	+ }
	11138	+ }
	11139	+
	11140	+ bool is_posinv_step() const
	11141	+ {
	11142	+ assert(_type == ast_step);
	11143	+
	11144	+ for (xpath_ast_node* n = _right; n; n = n->_next)
	11145	+ {
	11146	+ assert(n->_type == ast_predicate);
	11147	+
	11148	+ if (n->_test != predicate_posinv)
	11149	+ return false;
	11150	+ }
	11151	+
	11152	+ return true;
	11153	+ }
	11154	+
	11155	+ xpath_value_type rettype() const
	11156	+ {
	11157	+ return static_cast<xpath_value_type>(_rettype);
	11158	+ }
	11159	+ };
	11160	+
	11161	+ static const size_t xpath_ast_depth_limit =
	11162	+ #ifdef PUGIXML_XPATH_DEPTH_LIMIT
	11163	+ PUGIXML_XPATH_DEPTH_LIMIT
	11164	+ #else
	11165	+ 1024
	11166	+ #endif
	11167	+ ;
	11168	+
	11169	+ struct xpath_parser
	11170	+ {
	11171	+ xpath_allocator* _alloc;
	11172	+ xpath_lexer _lexer;
	11173	+
	11174	+ const char_t* _query;
	11175	+ xpath_variable_set* _variables;
	11176	+
	11177	+ xpath_parse_result* _result;
	11178	+
	11179	+ char_t _scratch[32];
	11180	+
	11181	+ size_t _depth;
	11182	+
	11183	+ xpath_ast_node* error(const char* message)
	11184	+ {
	11185	+ _result->error = message;
	11186	+ _result->offset = _lexer.current_pos() - _query;
	11187	+
	11188	+ return 0;
	11189	+ }
	11190	+
	11191	+ xpath_ast_node* error_oom()
	11192	+ {
	11193	+ assert(_alloc->_error);
	11194	+ *_alloc->_error = true;
	11195	+
	11196	+ return 0;
	11197	+ }
	11198	+
	11199	+ xpath_ast_node* error_rec()
	11200	+ {
	11201	+ return error("Exceeded maximum allowed query depth");
	11202	+ }
	11203	+
	11204	+ void* alloc_node()
	11205	+ {
	11206	+ return _alloc->allocate(sizeof(xpath_ast_node));
	11207	+ }
	11208	+
	11209	+ xpath_ast_node* alloc_node(ast_type_t type, xpath_value_type rettype, const char_t* value)
	11210	+ {
	11211	+ void* memory = alloc_node();
	11212	+ return memory ? new (memory) xpath_ast_node(type, rettype, value) : 0;
	11213	+ }
	11214	+
	11215	+ xpath_ast_node* alloc_node(ast_type_t type, xpath_value_type rettype, double value)
	11216	+ {
	11217	+ void* memory = alloc_node();
	11218	+ return memory ? new (memory) xpath_ast_node(type, rettype, value) : 0;
	11219	+ }
	11220	+
	11221	+ xpath_ast_node* alloc_node(ast_type_t type, xpath_value_type rettype, xpath_variable* value)
	11222	+ {
	11223	+ void* memory = alloc_node();
	11224	+ return memory ? new (memory) xpath_ast_node(type, rettype, value) : 0;
	11225	+ }
	11226	+
	11227	+ xpath_ast_node* alloc_node(ast_type_t type, xpath_value_type rettype, xpath_ast_node* left = 0, xpath_ast_node* right = 0)
	11228	+ {
	11229	+ void* memory = alloc_node();
	11230	+ return memory ? new (memory) xpath_ast_node(type, rettype, left, right) : 0;
	11231	+ }
	11232	+
	11233	+ xpath_ast_node* alloc_node(ast_type_t type, xpath_ast_node* left, axis_t axis, nodetest_t test, const char_t* contents)
	11234	+ {
	11235	+ void* memory = alloc_node();
	11236	+ return memory ? new (memory) xpath_ast_node(type, left, axis, test, contents) : 0;
	11237	+ }
	11238	+
	11239	+ xpath_ast_node* alloc_node(ast_type_t type, xpath_ast_node* left, xpath_ast_node* right, predicate_t test)
	11240	+ {
	11241	+ void* memory = alloc_node();
	11242	+ return memory ? new (memory) xpath_ast_node(type, left, right, test) : 0;
	11243	+ }
	11244	+
	11245	+ const char_t* alloc_string(const xpath_lexer_string& value)
	11246	+ {
	11247	+ if (!value.begin)
	11248	+ return PUGIXML_TEXT("");
	11249	+
	11250	+ size_t length = static_cast<size_t>(value.end - value.begin);
	11251	+
	11252	+ char_t* c = static_cast<char_t>(_alloc->allocate((length + 1) sizeof(char_t)));
	11253	+ if (!c) return 0;
	11254	+
	11255	+ memcpy(c, value.begin, length * sizeof(char_t));
	11256	+ c[length] = 0;
	11257	+
	11258	+ return c;
	11259	+ }
	11260	+
	11261	+ xpath_ast_node* parse_function(const xpath_lexer_string& name, size_t argc, xpath_ast_node* args[2])
	11262	+ {
	11263	+ switch (name.begin[0])
	11264	+ {
	11265	+ case 'b':
	11266	+ if (name == PUGIXML_TEXT("boolean") && argc == 1)
	11267	+ return alloc_node(ast_func_boolean, xpath_type_boolean, args[0]);
	11268	+
	11269	+ break;
	11270	+
	11271	+ case 'c':
	11272	+ if (name == PUGIXML_TEXT("count") && argc == 1)
	11273	+ {
	11274	+ if (args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
	11275	+ return alloc_node(ast_func_count, xpath_type_number, args[0]);
	11276	+ }
	11277	+ else if (name == PUGIXML_TEXT("contains") && argc == 2)
	11278	+ return alloc_node(ast_func_contains, xpath_type_boolean, args[0], args[1]);
	11279	+ else if (name == PUGIXML_TEXT("concat") && argc >= 2)
	11280	+ return alloc_node(ast_func_concat, xpath_type_string, args[0], args[1]);
	11281	+ else if (name == PUGIXML_TEXT("ceiling") && argc == 1)
	11282	+ return alloc_node(ast_func_ceiling, xpath_type_number, args[0]);
	11283	+
	11284	+ break;
	11285	+
	11286	+ case 'f':
	11287	+ if (name == PUGIXML_TEXT("false") && argc == 0)
	11288	+ return alloc_node(ast_func_false, xpath_type_boolean);
	11289	+ else if (name == PUGIXML_TEXT("floor") && argc == 1)
	11290	+ return alloc_node(ast_func_floor, xpath_type_number, args[0]);
	11291	+
	11292	+ break;
	11293	+
	11294	+ case 'i':
	11295	+ if (name == PUGIXML_TEXT("id") && argc == 1)
	11296	+ return alloc_node(ast_func_id, xpath_type_node_set, args[0]);
	11297	+
	11298	+ break;
	11299	+
	11300	+ case 'l':
	11301	+ if (name == PUGIXML_TEXT("last") && argc == 0)
	11302	+ return alloc_node(ast_func_last, xpath_type_number);
	11303	+ else if (name == PUGIXML_TEXT("lang") && argc == 1)
	11304	+ return alloc_node(ast_func_lang, xpath_type_boolean, args[0]);
	11305	+ else if (name == PUGIXML_TEXT("local-name") && argc <= 1)
	11306	+ {
	11307	+ if (argc == 1 && args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
	11308	+ return alloc_node(argc == 0 ? ast_func_local_name_0 : ast_func_local_name_1, xpath_type_string, args[0]);
	11309	+ }
	11310	+
	11311	+ break;
	11312	+
	11313	+ case 'n':
	11314	+ if (name == PUGIXML_TEXT("name") && argc <= 1)
	11315	+ {
	11316	+ if (argc == 1 && args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
	11317	+ return alloc_node(argc == 0 ? ast_func_name_0 : ast_func_name_1, xpath_type_string, args[0]);
	11318	+ }
	11319	+ else if (name == PUGIXML_TEXT("namespace-uri") && argc <= 1)
	11320	+ {
	11321	+ if (argc == 1 && args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
	11322	+ return alloc_node(argc == 0 ? ast_func_namespace_uri_0 : ast_func_namespace_uri_1, xpath_type_string, args[0]);
	11323	+ }
	11324	+ else if (name == PUGIXML_TEXT("normalize-space") && argc <= 1)
	11325	+ return alloc_node(argc == 0 ? ast_func_normalize_space_0 : ast_func_normalize_space_1, xpath_type_string, args[0], args[1]);
	11326	+ else if (name == PUGIXML_TEXT("not") && argc == 1)
	11327	+ return alloc_node(ast_func_not, xpath_type_boolean, args[0]);
	11328	+ else if (name == PUGIXML_TEXT("number") && argc <= 1)
	11329	+ return alloc_node(argc == 0 ? ast_func_number_0 : ast_func_number_1, xpath_type_number, args[0]);
	11330	+
	11331	+ break;
	11332	+
	11333	+ case 'p':
	11334	+ if (name == PUGIXML_TEXT("position") && argc == 0)
	11335	+ return alloc_node(ast_func_position, xpath_type_number);
	11336	+
	11337	+ break;
	11338	+
	11339	+ case 'r':
	11340	+ if (name == PUGIXML_TEXT("round") && argc == 1)
	11341	+ return alloc_node(ast_func_round, xpath_type_number, args[0]);
	11342	+
	11343	+ break;
	11344	+
	11345	+ case 's':
	11346	+ if (name == PUGIXML_TEXT("string") && argc <= 1)
	11347	+ return alloc_node(argc == 0 ? ast_func_string_0 : ast_func_string_1, xpath_type_string, args[0]);
	11348	+ else if (name == PUGIXML_TEXT("string-length") && argc <= 1)
	11349	+ return alloc_node(argc == 0 ? ast_func_string_length_0 : ast_func_string_length_1, xpath_type_number, args[0]);
	11350	+ else if (name == PUGIXML_TEXT("starts-with") && argc == 2)
	11351	+ return alloc_node(ast_func_starts_with, xpath_type_boolean, args[0], args[1]);
	11352	+ else if (name == PUGIXML_TEXT("substring-before") && argc == 2)
	11353	+ return alloc_node(ast_func_substring_before, xpath_type_string, args[0], args[1]);
	11354	+ else if (name == PUGIXML_TEXT("substring-after") && argc == 2)
	11355	+ return alloc_node(ast_func_substring_after, xpath_type_string, args[0], args[1]);
	11356	+ else if (name == PUGIXML_TEXT("substring") && (argc == 2 \|\| argc == 3))
	11357	+ return alloc_node(argc == 2 ? ast_func_substring_2 : ast_func_substring_3, xpath_type_string, args[0], args[1]);
	11358	+ else if (name == PUGIXML_TEXT("sum") && argc == 1)
	11359	+ {
	11360	+ if (args[0]->rettype() != xpath_type_node_set) return error("Function has to be applied to node set");
	11361	+ return alloc_node(ast_func_sum, xpath_type_number, args[0]);
	11362	+ }
	11363	+
	11364	+ break;
	11365	+
	11366	+ case 't':
	11367	+ if (name == PUGIXML_TEXT("translate") && argc == 3)
	11368	+ return alloc_node(ast_func_translate, xpath_type_string, args[0], args[1]);
	11369	+ else if (name == PUGIXML_TEXT("true") && argc == 0)
	11370	+ return alloc_node(ast_func_true, xpath_type_boolean);
	11371	+
	11372	+ break;
	11373	+
	11374	+ default:
	11375	+ break;
	11376	+ }
	11377	+
	11378	+ return error("Unrecognized function or wrong parameter count");
	11379	+ }
	11380	+
	11381	+ axis_t parse_axis_name(const xpath_lexer_string& name, bool& specified)
	11382	+ {
	11383	+ specified = true;
	11384	+
	11385	+ switch (name.begin[0])
	11386	+ {
	11387	+ case 'a':
	11388	+ if (name == PUGIXML_TEXT("ancestor"))
	11389	+ return axis_ancestor;
	11390	+ else if (name == PUGIXML_TEXT("ancestor-or-self"))
	11391	+ return axis_ancestor_or_self;
	11392	+ else if (name == PUGIXML_TEXT("attribute"))
	11393	+ return axis_attribute;
	11394	+
	11395	+ break;
	11396	+
	11397	+ case 'c':
	11398	+ if (name == PUGIXML_TEXT("child"))
	11399	+ return axis_child;
	11400	+
	11401	+ break;
	11402	+
	11403	+ case 'd':
	11404	+ if (name == PUGIXML_TEXT("descendant"))
	11405	+ return axis_descendant;
	11406	+ else if (name == PUGIXML_TEXT("descendant-or-self"))
	11407	+ return axis_descendant_or_self;
	11408	+
	11409	+ break;
	11410	+
	11411	+ case 'f':
	11412	+ if (name == PUGIXML_TEXT("following"))
	11413	+ return axis_following;
	11414	+ else if (name == PUGIXML_TEXT("following-sibling"))
	11415	+ return axis_following_sibling;
	11416	+
	11417	+ break;
	11418	+
	11419	+ case 'n':
	11420	+ if (name == PUGIXML_TEXT("namespace"))
	11421	+ return axis_namespace;
	11422	+
	11423	+ break;
	11424	+
	11425	+ case 'p':
	11426	+ if (name == PUGIXML_TEXT("parent"))
	11427	+ return axis_parent;
	11428	+ else if (name == PUGIXML_TEXT("preceding"))
	11429	+ return axis_preceding;
	11430	+ else if (name == PUGIXML_TEXT("preceding-sibling"))
	11431	+ return axis_preceding_sibling;
	11432	+
	11433	+ break;
	11434	+
	11435	+ case 's':
	11436	+ if (name == PUGIXML_TEXT("self"))
	11437	+ return axis_self;
	11438	+
	11439	+ break;
	11440	+
	11441	+ default:
	11442	+ break;
	11443	+ }
	11444	+
	11445	+ specified = false;
	11446	+ return axis_child;
	11447	+ }
	11448	+
	11449	+ nodetest_t parse_node_test_type(const xpath_lexer_string& name)
	11450	+ {
	11451	+ switch (name.begin[0])
	11452	+ {
	11453	+ case 'c':
	11454	+ if (name == PUGIXML_TEXT("comment"))
	11455	+ return nodetest_type_comment;
	11456	+
	11457	+ break;
	11458	+
	11459	+ case 'n':
	11460	+ if (name == PUGIXML_TEXT("node"))
	11461	+ return nodetest_type_node;
	11462	+
	11463	+ break;
	11464	+
	11465	+ case 'p':
	11466	+ if (name == PUGIXML_TEXT("processing-instruction"))
	11467	+ return nodetest_type_pi;
	11468	+
	11469	+ break;
	11470	+
	11471	+ case 't':
	11472	+ if (name == PUGIXML_TEXT("text"))
	11473	+ return nodetest_type_text;
	11474	+
	11475	+ break;
	11476	+
	11477	+ default:
	11478	+ break;
	11479	+ }
	11480	+
	11481	+ return nodetest_none;
	11482	+ }
	11483	+
	11484	+ // PrimaryExpr ::= VariableReference \| '(' Expr ')' \| Literal \| Number \| FunctionCall
	11485	+ xpath_ast_node* parse_primary_expression()
	11486	+ {
	11487	+ switch (_lexer.current())
	11488	+ {
	11489	+ case lex_var_ref:
	11490	+ {
	11491	+ xpath_lexer_string name = _lexer.contents();
	11492	+
	11493	+ if (!_variables)
	11494	+ return error("Unknown variable: variable set is not provided");
	11495	+
	11496	+ xpath_variable* var = 0;
	11497	+ if (!get_variable_scratch(_scratch, _variables, name.begin, name.end, &var))
	11498	+ return error_oom();
	11499	+
	11500	+ if (!var)
	11501	+ return error("Unknown variable: variable set does not contain the given name");
	11502	+
	11503	+ _lexer.next();
	11504	+
	11505	+ return alloc_node(ast_variable, var->type(), var);
	11506	+ }
	11507	+
	11508	+ case lex_open_brace:
	11509	+ {
	11510	+ _lexer.next();
	11511	+
	11512	+ xpath_ast_node* n = parse_expression();
	11513	+ if (!n) return 0;
	11514	+
	11515	+ if (_lexer.current() != lex_close_brace)
	11516	+ return error("Expected ')' to match an opening '('");
	11517	+
	11518	+ _lexer.next();
	11519	+
	11520	+ return n;
	11521	+ }
	11522	+
	11523	+ case lex_quoted_string:
	11524	+ {
	11525	+ const char_t* value = alloc_string(_lexer.contents());
	11526	+ if (!value) return 0;
	11527	+
	11528	+ _lexer.next();
	11529	+
	11530	+ return alloc_node(ast_string_constant, xpath_type_string, value);
	11531	+ }
	11532	+
	11533	+ case lex_number:
	11534	+ {
	11535	+ double value = 0;
	11536	+
	11537	+ if (!convert_string_to_number_scratch(_scratch, _lexer.contents().begin, _lexer.contents().end, &value))
	11538	+ return error_oom();
	11539	+
	11540	+ _lexer.next();
	11541	+
	11542	+ return alloc_node(ast_number_constant, xpath_type_number, value);
	11543	+ }
	11544	+
	11545	+ case lex_string:
	11546	+ {
	11547	+ xpath_ast_node* args[2] = {0};
	11548	+ size_t argc = 0;
	11549	+
	11550	+ xpath_lexer_string function = _lexer.contents();
	11551	+ _lexer.next();
	11552	+
	11553	+ xpath_ast_node* last_arg = 0;
	11554	+
	11555	+ if (_lexer.current() != lex_open_brace)
	11556	+ return error("Unrecognized function call");
	11557	+ _lexer.next();
	11558	+
	11559	+ size_t old_depth = _depth;
	11560	+
	11561	+ while (_lexer.current() != lex_close_brace)
	11562	+ {
	11563	+ if (argc > 0)
	11564	+ {
	11565	+ if (_lexer.current() != lex_comma)
	11566	+ return error("No comma between function arguments");
	11567	+ _lexer.next();
	11568	+ }
	11569	+
	11570	+ if (++_depth > xpath_ast_depth_limit)
	11571	+ return error_rec();
	11572	+
	11573	+ xpath_ast_node* n = parse_expression();
	11574	+ if (!n) return 0;
	11575	+
	11576	+ if (argc < 2) args[argc] = n;
	11577	+ else last_arg->set_next(n);
	11578	+
	11579	+ argc++;
	11580	+ last_arg = n;
	11581	+ }
	11582	+
	11583	+ _lexer.next();
	11584	+
	11585	+ _depth = old_depth;
	11586	+
	11587	+ return parse_function(function, argc, args);
	11588	+ }
	11589	+
	11590	+ default:
	11591	+ return error("Unrecognizable primary expression");
	11592	+ }
	11593	+ }
	11594	+
	11595	+ // FilterExpr ::= PrimaryExpr \| FilterExpr Predicate
	11596	+ // Predicate ::= '[' PredicateExpr ']'
	11597	+ // PredicateExpr ::= Expr
	11598	+ xpath_ast_node* parse_filter_expression()
	11599	+ {
	11600	+ xpath_ast_node* n = parse_primary_expression();
	11601	+ if (!n) return 0;
	11602	+
	11603	+ size_t old_depth = _depth;
	11604	+
	11605	+ while (_lexer.current() == lex_open_square_brace)
	11606	+ {
	11607	+ _lexer.next();
	11608	+
	11609	+ if (++_depth > xpath_ast_depth_limit)
	11610	+ return error_rec();
	11611	+
	11612	+ if (n->rettype() != xpath_type_node_set)
	11613	+ return error("Predicate has to be applied to node set");
	11614	+
	11615	+ xpath_ast_node* expr = parse_expression();
	11616	+ if (!expr) return 0;
	11617	+
	11618	+ n = alloc_node(ast_filter, n, expr, predicate_default);
	11619	+ if (!n) return 0;
	11620	+
	11621	+ if (_lexer.current() != lex_close_square_brace)
	11622	+ return error("Expected ']' to match an opening '['");
	11623	+
	11624	+ _lexer.next();
	11625	+ }
	11626	+
	11627	+ _depth = old_depth;
	11628	+
	11629	+ return n;
	11630	+ }
	11631	+
	11632	+ // Step ::= AxisSpecifier NodeTest Predicate* \| AbbreviatedStep
	11633	+ // AxisSpecifier ::= AxisName '::' \| '@'?
	11634	+ // NodeTest ::= NameTest \| NodeType '(' ')' \| 'processing-instruction' '(' Literal ')'
	11635	+ // NameTest ::= '' \| NCName ':' '' \| QName
	11636	+ // AbbreviatedStep ::= '.' \| '..'
	11637	+ xpath_ast_node* parse_step(xpath_ast_node* set)
	11638	+ {
	11639	+ if (set && set->rettype() != xpath_type_node_set)
	11640	+ return error("Step has to be applied to node set");
	11641	+
	11642	+ bool axis_specified = false;
	11643	+ axis_t axis = axis_child; // implied child axis
	11644	+
	11645	+ if (_lexer.current() == lex_axis_attribute)
	11646	+ {
	11647	+ axis = axis_attribute;
	11648	+ axis_specified = true;
	11649	+
	11650	+ _lexer.next();
	11651	+ }
	11652	+ else if (_lexer.current() == lex_dot)
	11653	+ {
	11654	+ _lexer.next();
	11655	+
	11656	+ if (_lexer.current() == lex_open_square_brace)
	11657	+ return error("Predicates are not allowed after an abbreviated step");
	11658	+
	11659	+ return alloc_node(ast_step, set, axis_self, nodetest_type_node, 0);
	11660	+ }
	11661	+ else if (_lexer.current() == lex_double_dot)
	11662	+ {
	11663	+ _lexer.next();
	11664	+
	11665	+ if (_lexer.current() == lex_open_square_brace)
	11666	+ return error("Predicates are not allowed after an abbreviated step");
	11667	+
	11668	+ return alloc_node(ast_step, set, axis_parent, nodetest_type_node, 0);
	11669	+ }
	11670	+
	11671	+ nodetest_t nt_type = nodetest_none;
	11672	+ xpath_lexer_string nt_name;
	11673	+
	11674	+ if (_lexer.current() == lex_string)
	11675	+ {
	11676	+ // node name test
	11677	+ nt_name = _lexer.contents();
	11678	+ _lexer.next();
	11679	+
	11680	+ // was it an axis name?
	11681	+ if (_lexer.current() == lex_double_colon)
	11682	+ {
	11683	+ // parse axis name
	11684	+ if (axis_specified)
	11685	+ return error("Two axis specifiers in one step");
	11686	+
	11687	+ axis = parse_axis_name(nt_name, axis_specified);
	11688	+
	11689	+ if (!axis_specified)
	11690	+ return error("Unknown axis");
	11691	+
	11692	+ // read actual node test
	11693	+ _lexer.next();
	11694	+
	11695	+ if (_lexer.current() == lex_multiply)
	11696	+ {
	11697	+ nt_type = nodetest_all;
	11698	+ nt_name = xpath_lexer_string();
	11699	+ _lexer.next();
	11700	+ }
	11701	+ else if (_lexer.current() == lex_string)
	11702	+ {
	11703	+ nt_name = _lexer.contents();
	11704	+ _lexer.next();
	11705	+ }
	11706	+ else
	11707	+ {
	11708	+ return error("Unrecognized node test");
	11709	+ }
	11710	+ }
	11711	+
	11712	+ if (nt_type == nodetest_none)
	11713	+ {
	11714	+ // node type test or processing-instruction
	11715	+ if (_lexer.current() == lex_open_brace)
	11716	+ {
	11717	+ _lexer.next();
	11718	+
	11719	+ if (_lexer.current() == lex_close_brace)
	11720	+ {
	11721	+ _lexer.next();
	11722	+
	11723	+ nt_type = parse_node_test_type(nt_name);
	11724	+
	11725	+ if (nt_type == nodetest_none)
	11726	+ return error("Unrecognized node type");
	11727	+
	11728	+ nt_name = xpath_lexer_string();
	11729	+ }
	11730	+ else if (nt_name == PUGIXML_TEXT("processing-instruction"))
	11731	+ {
	11732	+ if (_lexer.current() != lex_quoted_string)
	11733	+ return error("Only literals are allowed as arguments to processing-instruction()");
	11734	+
	11735	+ nt_type = nodetest_pi;
	11736	+ nt_name = _lexer.contents();
	11737	+ _lexer.next();
	11738	+
	11739	+ if (_lexer.current() != lex_close_brace)
	11740	+ return error("Unmatched brace near processing-instruction()");
	11741	+ _lexer.next();
	11742	+ }
	11743	+ else
	11744	+ {
	11745	+ return error("Unmatched brace near node type test");
	11746	+ }
	11747	+ }
	11748	+ // QName or NCName:*
	11749	+ else
	11750	+ {
	11751	+ if (nt_name.end - nt_name.begin > 2 && nt_name.end[-2] == ':' && nt_name.end[-1] == '') // NCName:
	11752	+ {
	11753	+ nt_name.end--; // erase *
	11754	+
	11755	+ nt_type = nodetest_all_in_namespace;
	11756	+ }
	11757	+ else
	11758	+ {
	11759	+ nt_type = nodetest_name;
	11760	+ }
	11761	+ }
	11762	+ }
	11763	+ }
	11764	+ else if (_lexer.current() == lex_multiply)
	11765	+ {
	11766	+ nt_type = nodetest_all;
	11767	+ _lexer.next();
	11768	+ }
	11769	+ else
	11770	+ {
	11771	+ return error("Unrecognized node test");
	11772	+ }
	11773	+
	11774	+ const char_t* nt_name_copy = alloc_string(nt_name);
	11775	+ if (!nt_name_copy) return 0;
	11776	+
	11777	+ xpath_ast_node* n = alloc_node(ast_step, set, axis, nt_type, nt_name_copy);
	11778	+ if (!n) return 0;
	11779	+
	11780	+ size_t old_depth = _depth;
	11781	+
	11782	+ xpath_ast_node* last = 0;
	11783	+
	11784	+ while (_lexer.current() == lex_open_square_brace)
	11785	+ {
	11786	+ _lexer.next();
	11787	+
	11788	+ if (++_depth > xpath_ast_depth_limit)
	11789	+ return error_rec();
	11790	+
	11791	+ xpath_ast_node* expr = parse_expression();
	11792	+ if (!expr) return 0;
	11793	+
	11794	+ xpath_ast_node* pred = alloc_node(ast_predicate, 0, expr, predicate_default);
	11795	+ if (!pred) return 0;
	11796	+
	11797	+ if (_lexer.current() != lex_close_square_brace)
	11798	+ return error("Expected ']' to match an opening '['");
	11799	+ _lexer.next();
	11800	+
	11801	+ if (last) last->set_next(pred);
	11802	+ else n->set_right(pred);
	11803	+
	11804	+ last = pred;
	11805	+ }
	11806	+
	11807	+ _depth = old_depth;
	11808	+
	11809	+ return n;
	11810	+ }
	11811	+
	11812	+ // RelativeLocationPath ::= Step \| RelativeLocationPath '/' Step \| RelativeLocationPath '//' Step
	11813	+ xpath_ast_node* parse_relative_location_path(xpath_ast_node* set)
	11814	+ {
	11815	+ xpath_ast_node* n = parse_step(set);
	11816	+ if (!n) return 0;
	11817	+
	11818	+ size_t old_depth = _depth;
	11819	+
	11820	+ while (_lexer.current() == lex_slash \|\| _lexer.current() == lex_double_slash)
	11821	+ {
	11822	+ lexeme_t l = _lexer.current();
	11823	+ _lexer.next();
	11824	+
	11825	+ if (++_depth > xpath_ast_depth_limit)
	11826	+ return error_rec();
	11827	+
	11828	+ if (l == lex_double_slash)
	11829	+ {
	11830	+ n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
	11831	+ if (!n) return 0;
	11832	+ }
	11833	+
	11834	+ n = parse_step(n);
	11835	+ if (!n) return 0;
	11836	+ }
	11837	+
	11838	+ _depth = old_depth;
	11839	+
	11840	+ return n;
	11841	+ }
	11842	+
	11843	+ // LocationPath ::= RelativeLocationPath \| AbsoluteLocationPath
	11844	+ // AbsoluteLocationPath ::= '/' RelativeLocationPath? \| '//' RelativeLocationPath
	11845	+ xpath_ast_node* parse_location_path()
	11846	+ {
	11847	+ if (_lexer.current() == lex_slash)
	11848	+ {
	11849	+ _lexer.next();
	11850	+
	11851	+ xpath_ast_node* n = alloc_node(ast_step_root, xpath_type_node_set);
	11852	+ if (!n) return 0;
	11853	+
	11854	+ // relative location path can start from axis_attribute, dot, double_dot, multiply and string lexemes; any other lexeme means standalone root path
	11855	+ lexeme_t l = _lexer.current();
	11856	+
	11857	+ if (l == lex_string \|\| l == lex_axis_attribute \|\| l == lex_dot \|\| l == lex_double_dot \|\| l == lex_multiply)
	11858	+ return parse_relative_location_path(n);
	11859	+ else
	11860	+ return n;
	11861	+ }
	11862	+ else if (_lexer.current() == lex_double_slash)
	11863	+ {
	11864	+ _lexer.next();
	11865	+
	11866	+ xpath_ast_node* n = alloc_node(ast_step_root, xpath_type_node_set);
	11867	+ if (!n) return 0;
	11868	+
	11869	+ n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
	11870	+ if (!n) return 0;
	11871	+
	11872	+ return parse_relative_location_path(n);
	11873	+ }
	11874	+
	11875	+ // 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
	11876	+ return parse_relative_location_path(0);
	11877	+ }
	11878	+
	11879	+ // PathExpr ::= LocationPath
	11880	+ // \| FilterExpr
	11881	+ // \| FilterExpr '/' RelativeLocationPath
	11882	+ // \| FilterExpr '//' RelativeLocationPath
	11883	+ // UnionExpr ::= PathExpr \| UnionExpr '\|' PathExpr
	11884	+ // UnaryExpr ::= UnionExpr \| '-' UnaryExpr
	11885	+ xpath_ast_node* parse_path_or_unary_expression()
	11886	+ {
	11887	+ // Clarification.
	11888	+ // PathExpr begins with either LocationPath or FilterExpr.
	11889	+ // FilterExpr begins with PrimaryExpr
	11890	+ // PrimaryExpr begins with '$' in case of it being a variable reference,
	11891	+ // '(' in case of it being an expression, string literal, number constant or
	11892	+ // function call.
	11893	+ if (_lexer.current() == lex_var_ref \|\| _lexer.current() == lex_open_brace \|\|
	11894	+ _lexer.current() == lex_quoted_string \|\| _lexer.current() == lex_number \|\|
	11895	+ _lexer.current() == lex_string)
	11896	+ {
	11897	+ if (_lexer.current() == lex_string)
	11898	+ {
	11899	+ // This is either a function call, or not - if not, we shall proceed with location path
	11900	+ const char_t* state = _lexer.state();
	11901	+
	11902	+ while (PUGI__IS_CHARTYPE(*state, ct_space)) ++state;
	11903	+
	11904	+ if (*state != '(')
	11905	+ return parse_location_path();
	11906	+
	11907	+ // This looks like a function call; however this still can be a node-test. Check it.
	11908	+ if (parse_node_test_type(_lexer.contents()) != nodetest_none)
	11909	+ return parse_location_path();
	11910	+ }
	11911	+
	11912	+ xpath_ast_node* n = parse_filter_expression();
	11913	+ if (!n) return 0;
	11914	+
	11915	+ if (_lexer.current() == lex_slash \|\| _lexer.current() == lex_double_slash)
	11916	+ {
	11917	+ lexeme_t l = _lexer.current();
	11918	+ _lexer.next();
	11919	+
	11920	+ if (l == lex_double_slash)
	11921	+ {
	11922	+ if (n->rettype() != xpath_type_node_set)
	11923	+ return error("Step has to be applied to node set");
	11924	+
	11925	+ n = alloc_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
	11926	+ if (!n) return 0;
	11927	+ }
	11928	+
	11929	+ // select from location path
	11930	+ return parse_relative_location_path(n);
	11931	+ }
	11932	+
	11933	+ return n;
	11934	+ }
	11935	+ else if (_lexer.current() == lex_minus)
	11936	+ {
	11937	+ _lexer.next();
	11938	+
	11939	+ // precedence 7+ - only parses union expressions
	11940	+ xpath_ast_node* n = parse_expression(7);
	11941	+ if (!n) return 0;
	11942	+
	11943	+ return alloc_node(ast_op_negate, xpath_type_number, n);
	11944	+ }
	11945	+ else
	11946	+ {
	11947	+ return parse_location_path();
	11948	+ }
	11949	+ }
	11950	+
	11951	+ struct binary_op_t
	11952	+ {
	11953	+ ast_type_t asttype;
	11954	+ xpath_value_type rettype;
	11955	+ int precedence;
	11956	+
	11957	+ binary_op_t(): asttype(ast_unknown), rettype(xpath_type_none), precedence(0)
	11958	+ {
	11959	+ }
	11960	+
	11961	+ binary_op_t(ast_type_t asttype_, xpath_value_type rettype_, int precedence_): asttype(asttype_), rettype(rettype_), precedence(precedence_)
	11962	+ {
	11963	+ }
	11964	+
	11965	+ static binary_op_t parse(xpath_lexer& lexer)
	11966	+ {
	11967	+ switch (lexer.current())
	11968	+ {
	11969	+ case lex_string:
	11970	+ if (lexer.contents() == PUGIXML_TEXT("or"))
	11971	+ return binary_op_t(ast_op_or, xpath_type_boolean, 1);
	11972	+ else if (lexer.contents() == PUGIXML_TEXT("and"))
	11973	+ return binary_op_t(ast_op_and, xpath_type_boolean, 2);
	11974	+ else if (lexer.contents() == PUGIXML_TEXT("div"))
	11975	+ return binary_op_t(ast_op_divide, xpath_type_number, 6);
	11976	+ else if (lexer.contents() == PUGIXML_TEXT("mod"))
	11977	+ return binary_op_t(ast_op_mod, xpath_type_number, 6);
	11978	+ else
	11979	+ return binary_op_t();
	11980	+
	11981	+ case lex_equal:
	11982	+ return binary_op_t(ast_op_equal, xpath_type_boolean, 3);
	11983	+
	11984	+ case lex_not_equal:
	11985	+ return binary_op_t(ast_op_not_equal, xpath_type_boolean, 3);
	11986	+
	11987	+ case lex_less:
	11988	+ return binary_op_t(ast_op_less, xpath_type_boolean, 4);
	11989	+
	11990	+ case lex_greater:
	11991	+ return binary_op_t(ast_op_greater, xpath_type_boolean, 4);
	11992	+
	11993	+ case lex_less_or_equal:
	11994	+ return binary_op_t(ast_op_less_or_equal, xpath_type_boolean, 4);
	11995	+
	11996	+ case lex_greater_or_equal:
	11997	+ return binary_op_t(ast_op_greater_or_equal, xpath_type_boolean, 4);
	11998	+
	11999	+ case lex_plus:
	12000	+ return binary_op_t(ast_op_add, xpath_type_number, 5);
	12001	+
	12002	+ case lex_minus:
	12003	+ return binary_op_t(ast_op_subtract, xpath_type_number, 5);
	12004	+
	12005	+ case lex_multiply:
	12006	+ return binary_op_t(ast_op_multiply, xpath_type_number, 6);
	12007	+
	12008	+ case lex_union:
	12009	+ return binary_op_t(ast_op_union, xpath_type_node_set, 7);
	12010	+
	12011	+ default:
	12012	+ return binary_op_t();
	12013	+ }
	12014	+ }
	12015	+ };
	12016	+
	12017	+ xpath_ast_node* parse_expression_rec(xpath_ast_node* lhs, int limit)
	12018	+ {
	12019	+ binary_op_t op = binary_op_t::parse(_lexer);
	12020	+
	12021	+ while (op.asttype != ast_unknown && op.precedence >= limit)
	12022	+ {
	12023	+ _lexer.next();
	12024	+
	12025	+ if (++_depth > xpath_ast_depth_limit)
	12026	+ return error_rec();
	12027	+
	12028	+ xpath_ast_node* rhs = parse_path_or_unary_expression();
	12029	+ if (!rhs) return 0;
	12030	+
	12031	+ binary_op_t nextop = binary_op_t::parse(_lexer);
	12032	+
	12033	+ while (nextop.asttype != ast_unknown && nextop.precedence > op.precedence)
	12034	+ {
	12035	+ rhs = parse_expression_rec(rhs, nextop.precedence);
	12036	+ if (!rhs) return 0;
	12037	+
	12038	+ nextop = binary_op_t::parse(_lexer);
	12039	+ }
	12040	+
	12041	+ if (op.asttype == ast_op_union && (lhs->rettype() != xpath_type_node_set \|\| rhs->rettype() != xpath_type_node_set))
	12042	+ return error("Union operator has to be applied to node sets");
	12043	+
	12044	+ lhs = alloc_node(op.asttype, op.rettype, lhs, rhs);
	12045	+ if (!lhs) return 0;
	12046	+
	12047	+ op = binary_op_t::parse(_lexer);
	12048	+ }
	12049	+
	12050	+ return lhs;
	12051	+ }
	12052	+
	12053	+ // Expr ::= OrExpr
	12054	+ // OrExpr ::= AndExpr \| OrExpr 'or' AndExpr
	12055	+ // AndExpr ::= EqualityExpr \| AndExpr 'and' EqualityExpr
	12056	+ // EqualityExpr ::= RelationalExpr
	12057	+ // \| EqualityExpr '=' RelationalExpr
	12058	+ // \| EqualityExpr '!=' RelationalExpr
	12059	+ // RelationalExpr ::= AdditiveExpr
	12060	+ // \| RelationalExpr '<' AdditiveExpr
	12061	+ // \| RelationalExpr '>' AdditiveExpr
	12062	+ // \| RelationalExpr '<=' AdditiveExpr
	12063	+ // \| RelationalExpr '>=' AdditiveExpr
	12064	+ // AdditiveExpr ::= MultiplicativeExpr
	12065	+ // \| AdditiveExpr '+' MultiplicativeExpr
	12066	+ // \| AdditiveExpr '-' MultiplicativeExpr
	12067	+ // MultiplicativeExpr ::= UnaryExpr
	12068	+ // \| MultiplicativeExpr '*' UnaryExpr
	12069	+ // \| MultiplicativeExpr 'div' UnaryExpr
	12070	+ // \| MultiplicativeExpr 'mod' UnaryExpr
	12071	+ xpath_ast_node* parse_expression(int limit = 0)
	12072	+ {
	12073	+ size_t old_depth = _depth;
	12074	+
	12075	+ if (++_depth > xpath_ast_depth_limit)
	12076	+ return error_rec();
	12077	+
	12078	+ xpath_ast_node* n = parse_path_or_unary_expression();
	12079	+ if (!n) return 0;
	12080	+
	12081	+ n = parse_expression_rec(n, limit);
	12082	+
	12083	+ _depth = old_depth;
	12084	+
	12085	+ return n;
	12086	+ }
	12087	+
	12088	+ xpath_parser(const char_t* query, xpath_variable_set* variables, xpath_allocator* alloc, xpath_parse_result* result): _alloc(alloc), _lexer(query), _query(query), _variables(variables), _result(result), _depth(0)
	12089	+ {
	12090	+ }
	12091	+
	12092	+ xpath_ast_node* parse()
	12093	+ {
	12094	+ xpath_ast_node* n = parse_expression();
	12095	+ if (!n) return 0;
	12096	+
	12097	+ assert(_depth == 0);
	12098	+
	12099	+ // check if there are unparsed tokens left
	12100	+ if (_lexer.current() != lex_eof)
	12101	+ return error("Incorrect query");
	12102	+
	12103	+ return n;
	12104	+ }
	12105	+
	12106	+ static xpath_ast_node* parse(const char_t* query, xpath_variable_set* variables, xpath_allocator* alloc, xpath_parse_result* result)
	12107	+ {
	12108	+ xpath_parser parser(query, variables, alloc, result);
	12109	+
	12110	+ return parser.parse();
	12111	+ }
	12112	+ };
	12113	+
	12114	+ struct xpath_query_impl
	12115	+ {
	12116	+ static xpath_query_impl* create()
	12117	+ {
	12118	+ void* memory = xml_memory::allocate(sizeof(xpath_query_impl));
	12119	+ if (!memory) return 0;
	12120	+
	12121	+ return new (memory) xpath_query_impl();
	12122	+ }
	12123	+
	12124	+ static void destroy(xpath_query_impl* impl)
	12125	+ {
	12126	+ // free all allocated pages
	12127	+ impl->alloc.release();
	12128	+
	12129	+ // free allocator memory (with the first page)
	12130	+ xml_memory::deallocate(impl);
	12131	+ }
	12132	+
	12133	+ xpath_query_impl(): root(0), alloc(&block, &oom), oom(false)
	12134	+ {
	12135	+ block.next = 0;
	12136	+ block.capacity = sizeof(block.data);
	12137	+ }
	12138	+
	12139	+ xpath_ast_node* root;
	12140	+ xpath_allocator alloc;
	12141	+ xpath_memory_block block;
	12142	+ bool oom;
	12143	+ };
	12144	+
	12145	+ PUGI__FN impl::xpath_ast_node* evaluate_node_set_prepare(xpath_query_impl* impl)
	12146	+ {
	12147	+ if (!impl) return 0;
	12148	+
	12149	+ if (impl->root->rettype() != xpath_type_node_set)
	12150	+ {
	12151	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12152	+ return 0;
	12153	+ #else
	12154	+ xpath_parse_result res;
	12155	+ res.error = "Expression does not evaluate to node set";
	12156	+
	12157	+ throw xpath_exception(res);
	12158	+ #endif
	12159	+ }
	12160	+
	12161	+ return impl->root;
	12162	+ }
	12163	+PUGI__NS_END
	12164	+
	12165	+namespace pugi
	12166	+{
	12167	+#ifndef PUGIXML_NO_EXCEPTIONS
	12168	+ PUGI__FN xpath_exception::xpath_exception(const xpath_parse_result& result_): _result(result_)
	12169	+ {
	12170	+ assert(_result.error);
	12171	+ }
	12172	+
	12173	+ PUGI__FN const char* xpath_exception::what() const throw()
	12174	+ {
	12175	+ return _result.error;
	12176	+ }
	12177	+
	12178	+ PUGI__FN const xpath_parse_result& xpath_exception::result() const
	12179	+ {
	12180	+ return _result;
	12181	+ }
	12182	+#endif
	12183	+
	12184	+ PUGI__FN xpath_node::xpath_node()
	12185	+ {
	12186	+ }
	12187	+
	12188	+ PUGI__FN xpath_node::xpath_node(const xml_node& node_): _node(node_)
	12189	+ {
	12190	+ }
	12191	+
	12192	+ PUGI__FN xpath_node::xpath_node(const xml_attribute& attribute_, const xml_node& parent_): _node(attribute_ ? parent_ : xml_node()), _attribute(attribute_)
	12193	+ {
	12194	+ }
	12195	+
	12196	+ PUGI__FN xml_node xpath_node::node() const
	12197	+ {
	12198	+ return _attribute ? xml_node() : _node;
	12199	+ }
	12200	+
	12201	+ PUGI__FN xml_attribute xpath_node::attribute() const
	12202	+ {
	12203	+ return _attribute;
	12204	+ }
	12205	+
	12206	+ PUGI__FN xml_node xpath_node::parent() const
	12207	+ {
	12208	+ return _attribute ? _node : _node.parent();
	12209	+ }
	12210	+
	12211	+ PUGI__FN static void unspecified_bool_xpath_node(xpath_node***)
	12212	+ {
	12213	+ }
	12214	+
	12215	+ PUGI__FN xpath_node::operator xpath_node::unspecified_bool_type() const
	12216	+ {
	12217	+ return (_node \|\| _attribute) ? unspecified_bool_xpath_node : 0;
	12218	+ }
	12219	+
	12220	+ PUGI__FN bool xpath_node::operator!() const
	12221	+ {
	12222	+ return !(_node \|\| _attribute);
	12223	+ }
	12224	+
	12225	+ PUGI__FN bool xpath_node::operator==(const xpath_node& n) const
	12226	+ {
	12227	+ return _node == n._node && _attribute == n._attribute;
	12228	+ }
	12229	+
	12230	+ PUGI__FN bool xpath_node::operator!=(const xpath_node& n) const
	12231	+ {
	12232	+ return _node != n._node \|\| _attribute != n._attribute;
	12233	+ }
	12234	+
	12235	+#ifdef __BORLANDC__
	12236	+ PUGI__FN bool operator&&(const xpath_node& lhs, bool rhs)
	12237	+ {
	12238	+ return (bool)lhs && rhs;
	12239	+ }
	12240	+
	12241	+ PUGI__FN bool operator\|\|(const xpath_node& lhs, bool rhs)
	12242	+ {
	12243	+ return (bool)lhs \|\| rhs;
	12244	+ }
	12245	+#endif
	12246	+
	12247	+ PUGI__FN void xpath_node_set::_assign(const_iterator begin_, const_iterator end_, type_t type_)
	12248	+ {
	12249	+ assert(begin_ <= end_);
	12250	+
	12251	+ size_t size_ = static_cast<size_t>(end_ - begin_);
	12252	+
	12253	+ // use internal buffer for 0 or 1 elements, heap buffer otherwise
	12254	+ xpath_node* storage = (size_ <= 1) ? _storage : static_cast<xpath_node>(impl::xml_memory::allocate(size_ sizeof(xpath_node)));
	12255	+
	12256	+ if (!storage)
	12257	+ {
	12258	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12259	+ return;
	12260	+ #else
	12261	+ throw std::bad_alloc();
	12262	+ #endif
	12263	+ }
	12264	+
	12265	+ // deallocate old buffer
	12266	+ if (_begin != _storage)
	12267	+ impl::xml_memory::deallocate(_begin);
	12268	+
	12269	+ // size check is necessary because for begin_ = end_ = nullptr, memcpy is UB
	12270	+ if (size_)
	12271	+ memcpy(storage, begin_, size_ * sizeof(xpath_node));
	12272	+
	12273	+ _begin = storage;
	12274	+ _end = storage + size_;
	12275	+ _type = type_;
	12276	+ }
	12277	+
	12278	+#ifdef PUGIXML_HAS_MOVE
	12279	+ PUGI__FN void xpath_node_set::_move(xpath_node_set& rhs) PUGIXML_NOEXCEPT
	12280	+ {
	12281	+ _type = rhs._type;
	12282	+ _storage[0] = rhs._storage[0];
	12283	+ _begin = (rhs._begin == rhs._storage) ? _storage : rhs._begin;
	12284	+ _end = _begin + (rhs._end - rhs._begin);
	12285	+
	12286	+ rhs._type = type_unsorted;
	12287	+ rhs._begin = rhs._storage;
	12288	+ rhs._end = rhs._storage;
	12289	+ }
	12290	+#endif
	12291	+
	12292	+ PUGI__FN xpath_node_set::xpath_node_set(): _type(type_unsorted), _begin(_storage), _end(_storage)
	12293	+ {
	12294	+ }
	12295	+
	12296	+ PUGI__FN xpath_node_set::xpath_node_set(const_iterator begin_, const_iterator end_, type_t type_): _type(type_unsorted), _begin(_storage), _end(_storage)
	12297	+ {
	12298	+ _assign(begin_, end_, type_);
	12299	+ }
	12300	+
	12301	+ PUGI__FN xpath_node_set::~xpath_node_set()
	12302	+ {
	12303	+ if (_begin != _storage)
	12304	+ impl::xml_memory::deallocate(_begin);
	12305	+ }
	12306	+
	12307	+ PUGI__FN xpath_node_set::xpath_node_set(const xpath_node_set& ns): _type(type_unsorted), _begin(_storage), _end(_storage)
	12308	+ {
	12309	+ _assign(ns._begin, ns._end, ns._type);
	12310	+ }
	12311	+
	12312	+ PUGI__FN xpath_node_set& xpath_node_set::operator=(const xpath_node_set& ns)
	12313	+ {
	12314	+ if (this == &ns) return *this;
	12315	+
	12316	+ _assign(ns._begin, ns._end, ns._type);
	12317	+
	12318	+ return *this;
	12319	+ }
	12320	+
	12321	+#ifdef PUGIXML_HAS_MOVE
	12322	+ PUGI__FN xpath_node_set::xpath_node_set(xpath_node_set&& rhs) PUGIXML_NOEXCEPT: _type(type_unsorted), _begin(_storage), _end(_storage)
	12323	+ {
	12324	+ _move(rhs);
	12325	+ }
	12326	+
	12327	+ PUGI__FN xpath_node_set& xpath_node_set::operator=(xpath_node_set&& rhs) PUGIXML_NOEXCEPT
	12328	+ {
	12329	+ if (this == &rhs) return *this;
	12330	+
	12331	+ if (_begin != _storage)
	12332	+ impl::xml_memory::deallocate(_begin);
	12333	+
	12334	+ _move(rhs);
	12335	+
	12336	+ return *this;
	12337	+ }
	12338	+#endif
	12339	+
	12340	+ PUGI__FN xpath_node_set::type_t xpath_node_set::type() const
	12341	+ {
	12342	+ return _type;
	12343	+ }
	12344	+
	12345	+ PUGI__FN size_t xpath_node_set::size() const
	12346	+ {
	12347	+ return _end - _begin;
	12348	+ }
	12349	+
	12350	+ PUGI__FN bool xpath_node_set::empty() const
	12351	+ {
	12352	+ return _begin == _end;
	12353	+ }
	12354	+
	12355	+ PUGI__FN const xpath_node& xpath_node_set::operator[](size_t index) const
	12356	+ {
	12357	+ assert(index < size());
	12358	+ return _begin[index];
	12359	+ }
	12360	+
	12361	+ PUGI__FN xpath_node_set::const_iterator xpath_node_set::begin() const
	12362	+ {
	12363	+ return _begin;
	12364	+ }
	12365	+
	12366	+ PUGI__FN xpath_node_set::const_iterator xpath_node_set::end() const
	12367	+ {
	12368	+ return _end;
	12369	+ }
	12370	+
	12371	+ PUGI__FN void xpath_node_set::sort(bool reverse)
	12372	+ {
	12373	+ _type = impl::xpath_sort(_begin, _end, _type, reverse);
	12374	+ }
	12375	+
	12376	+ PUGI__FN xpath_node xpath_node_set::first() const
	12377	+ {
	12378	+ return impl::xpath_first(_begin, _end, _type);
	12379	+ }
	12380	+
	12381	+ PUGI__FN xpath_parse_result::xpath_parse_result(): error("Internal error"), offset(0)
	12382	+ {
	12383	+ }
	12384	+
	12385	+ PUGI__FN xpath_parse_result::operator bool() const
	12386	+ {
	12387	+ return error == 0;
	12388	+ }
	12389	+
	12390	+ PUGI__FN const char* xpath_parse_result::description() const
	12391	+ {
	12392	+ return error ? error : "No error";
	12393	+ }
	12394	+
	12395	+ PUGI__FN xpath_variable::xpath_variable(xpath_value_type type_): _type(type_), _next(0)
	12396	+ {
	12397	+ }
	12398	+
	12399	+ PUGI__FN const char_t* xpath_variable::name() const
	12400	+ {
	12401	+ switch (_type)
	12402	+ {
	12403	+ case xpath_type_node_set:
	12404	+ return static_cast<const impl::xpath_variable_node_set*>(this)->name;
	12405	+
	12406	+ case xpath_type_number:
	12407	+ return static_cast<const impl::xpath_variable_number*>(this)->name;
	12408	+
	12409	+ case xpath_type_string:
	12410	+ return static_cast<const impl::xpath_variable_string*>(this)->name;
	12411	+
	12412	+ case xpath_type_boolean:
	12413	+ return static_cast<const impl::xpath_variable_boolean*>(this)->name;
	12414	+
	12415	+ default:
	12416	+ assert(false && "Invalid variable type"); // unreachable
	12417	+ return 0;
	12418	+ }
	12419	+ }
	12420	+
	12421	+ PUGI__FN xpath_value_type xpath_variable::type() const
	12422	+ {
	12423	+ return _type;
	12424	+ }
	12425	+
	12426	+ PUGI__FN bool xpath_variable::get_boolean() const
	12427	+ {
	12428	+ return (_type == xpath_type_boolean) ? static_cast<const impl::xpath_variable_boolean*>(this)->value : false;
	12429	+ }
	12430	+
	12431	+ PUGI__FN double xpath_variable::get_number() const
	12432	+ {
	12433	+ return (_type == xpath_type_number) ? static_cast<const impl::xpath_variable_number*>(this)->value : impl::gen_nan();
	12434	+ }
	12435	+
	12436	+ PUGI__FN const char_t* xpath_variable::get_string() const
	12437	+ {
	12438	+ const char_t* value = (_type == xpath_type_string) ? static_cast<const impl::xpath_variable_string*>(this)->value : 0;
	12439	+ return value ? value : PUGIXML_TEXT("");
	12440	+ }
	12441	+
	12442	+ PUGI__FN const xpath_node_set& xpath_variable::get_node_set() const
	12443	+ {
	12444	+ return (_type == xpath_type_node_set) ? static_cast<const impl::xpath_variable_node_set*>(this)->value : impl::dummy_node_set;
	12445	+ }
	12446	+
	12447	+ PUGI__FN bool xpath_variable::set(bool value)
	12448	+ {
	12449	+ if (_type != xpath_type_boolean) return false;
	12450	+
	12451	+ static_cast<impl::xpath_variable_boolean*>(this)->value = value;
	12452	+ return true;
	12453	+ }
	12454	+
	12455	+ PUGI__FN bool xpath_variable::set(double value)
	12456	+ {
	12457	+ if (_type != xpath_type_number) return false;
	12458	+
	12459	+ static_cast<impl::xpath_variable_number*>(this)->value = value;
	12460	+ return true;
	12461	+ }
	12462	+
	12463	+ PUGI__FN bool xpath_variable::set(const char_t* value)
	12464	+ {
	12465	+ if (_type != xpath_type_string) return false;
	12466	+
	12467	+ impl::xpath_variable_string* var = static_cast<impl::xpath_variable_string*>(this);
	12468	+
	12469	+ // duplicate string
	12470	+ size_t size = (impl::strlength(value) + 1) * sizeof(char_t);
	12471	+
	12472	+ char_t* copy = static_cast<char_t*>(impl::xml_memory::allocate(size));
	12473	+ if (!copy) return false;
	12474	+
	12475	+ memcpy(copy, value, size);
	12476	+
	12477	+ // replace old string
	12478	+ if (var->value) impl::xml_memory::deallocate(var->value);
	12479	+ var->value = copy;
	12480	+
	12481	+ return true;
	12482	+ }
	12483	+
	12484	+ PUGI__FN bool xpath_variable::set(const xpath_node_set& value)
	12485	+ {
	12486	+ if (_type != xpath_type_node_set) return false;
	12487	+
	12488	+ static_cast<impl::xpath_variable_node_set*>(this)->value = value;
	12489	+ return true;
	12490	+ }
	12491	+
	12492	+ PUGI__FN xpath_variable_set::xpath_variable_set()
	12493	+ {
	12494	+ for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
	12495	+ _data[i] = 0;
	12496	+ }
	12497	+
	12498	+ PUGI__FN xpath_variable_set::~xpath_variable_set()
	12499	+ {
	12500	+ for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
	12501	+ _destroy(_data[i]);
	12502	+ }
	12503	+
	12504	+ PUGI__FN xpath_variable_set::xpath_variable_set(const xpath_variable_set& rhs)
	12505	+ {
	12506	+ for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
	12507	+ _data[i] = 0;
	12508	+
	12509	+ _assign(rhs);
	12510	+ }
	12511	+
	12512	+ PUGI__FN xpath_variable_set& xpath_variable_set::operator=(const xpath_variable_set& rhs)
	12513	+ {
	12514	+ if (this == &rhs) return *this;
	12515	+
	12516	+ _assign(rhs);
	12517	+
	12518	+ return *this;
	12519	+ }
	12520	+
	12521	+#ifdef PUGIXML_HAS_MOVE
	12522	+ PUGI__FN xpath_variable_set::xpath_variable_set(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT
	12523	+ {
	12524	+ for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
	12525	+ {
	12526	+ _data[i] = rhs._data[i];
	12527	+ rhs._data[i] = 0;
	12528	+ }
	12529	+ }
	12530	+
	12531	+ PUGI__FN xpath_variable_set& xpath_variable_set::operator=(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT
	12532	+ {
	12533	+ for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
	12534	+ {
	12535	+ _destroy(_data[i]);
	12536	+
	12537	+ _data[i] = rhs._data[i];
	12538	+ rhs._data[i] = 0;
	12539	+ }
	12540	+
	12541	+ return *this;
	12542	+ }
	12543	+#endif
	12544	+
	12545	+ PUGI__FN void xpath_variable_set::_assign(const xpath_variable_set& rhs)
	12546	+ {
	12547	+ xpath_variable_set temp;
	12548	+
	12549	+ for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
	12550	+ if (rhs._data[i] && !_clone(rhs._data[i], &temp._data[i]))
	12551	+ return;
	12552	+
	12553	+ _swap(temp);
	12554	+ }
	12555	+
	12556	+ PUGI__FN void xpath_variable_set::_swap(xpath_variable_set& rhs)
	12557	+ {
	12558	+ for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
	12559	+ {
	12560	+ xpath_variable* chain = _data[i];
	12561	+
	12562	+ _data[i] = rhs._data[i];
	12563	+ rhs._data[i] = chain;
	12564	+ }
	12565	+ }
	12566	+
	12567	+ PUGI__FN xpath_variable* xpath_variable_set::_find(const char_t* name) const
	12568	+ {
	12569	+ const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
	12570	+ size_t hash = impl::hash_string(name) % hash_size;
	12571	+
	12572	+ // look for existing variable
	12573	+ for (xpath_variable* var = _data[hash]; var; var = var->_next)
	12574	+ if (impl::strequal(var->name(), name))
	12575	+ return var;
	12576	+
	12577	+ return 0;
	12578	+ }
	12579	+
	12580	+ PUGI__FN bool xpath_variable_set::_clone(xpath_variable* var, xpath_variable** out_result)
	12581	+ {
	12582	+ xpath_variable* last = 0;
	12583	+
	12584	+ while (var)
	12585	+ {
	12586	+ // allocate storage for new variable
	12587	+ xpath_variable* nvar = impl::new_xpath_variable(var->_type, var->name());
	12588	+ if (!nvar) return false;
	12589	+
	12590	+ // link the variable to the result immediately to handle failures gracefully
	12591	+ if (last)
	12592	+ last->_next = nvar;
	12593	+ else
	12594	+ *out_result = nvar;
	12595	+
	12596	+ last = nvar;
	12597	+
	12598	+ // copy the value; this can fail due to out-of-memory conditions
	12599	+ if (!impl::copy_xpath_variable(nvar, var)) return false;
	12600	+
	12601	+ var = var->_next;
	12602	+ }
	12603	+
	12604	+ return true;
	12605	+ }
	12606	+
	12607	+ PUGI__FN void xpath_variable_set::_destroy(xpath_variable* var)
	12608	+ {
	12609	+ while (var)
	12610	+ {
	12611	+ xpath_variable* next = var->_next;
	12612	+
	12613	+ impl::delete_xpath_variable(var->_type, var);
	12614	+
	12615	+ var = next;
	12616	+ }
	12617	+ }
	12618	+
	12619	+ PUGI__FN xpath_variable* xpath_variable_set::add(const char_t* name, xpath_value_type type)
	12620	+ {
	12621	+ const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
	12622	+ size_t hash = impl::hash_string(name) % hash_size;
	12623	+
	12624	+ // look for existing variable
	12625	+ for (xpath_variable* var = _data[hash]; var; var = var->_next)
	12626	+ if (impl::strequal(var->name(), name))
	12627	+ return var->type() == type ? var : 0;
	12628	+
	12629	+ // add new variable
	12630	+ xpath_variable* result = impl::new_xpath_variable(type, name);
	12631	+
	12632	+ if (result)
	12633	+ {
	12634	+ result->_next = _data[hash];
	12635	+
	12636	+ _data[hash] = result;
	12637	+ }
	12638	+
	12639	+ return result;
	12640	+ }
	12641	+
	12642	+ PUGI__FN bool xpath_variable_set::set(const char_t* name, bool value)
	12643	+ {
	12644	+ xpath_variable* var = add(name, xpath_type_boolean);
	12645	+ return var ? var->set(value) : false;
	12646	+ }
	12647	+
	12648	+ PUGI__FN bool xpath_variable_set::set(const char_t* name, double value)
	12649	+ {
	12650	+ xpath_variable* var = add(name, xpath_type_number);
	12651	+ return var ? var->set(value) : false;
	12652	+ }
	12653	+
	12654	+ PUGI__FN bool xpath_variable_set::set(const char_t* name, const char_t* value)
	12655	+ {
	12656	+ xpath_variable* var = add(name, xpath_type_string);
	12657	+ return var ? var->set(value) : false;
	12658	+ }
	12659	+
	12660	+ PUGI__FN bool xpath_variable_set::set(const char_t* name, const xpath_node_set& value)
	12661	+ {
	12662	+ xpath_variable* var = add(name, xpath_type_node_set);
	12663	+ return var ? var->set(value) : false;
	12664	+ }
	12665	+
	12666	+ PUGI__FN xpath_variable* xpath_variable_set::get(const char_t* name)
	12667	+ {
	12668	+ return _find(name);
	12669	+ }
	12670	+
	12671	+ PUGI__FN const xpath_variable* xpath_variable_set::get(const char_t* name) const
	12672	+ {
	12673	+ return _find(name);
	12674	+ }
	12675	+
	12676	+ PUGI__FN xpath_query::xpath_query(const char_t* query, xpath_variable_set* variables): _impl(0)
	12677	+ {
	12678	+ impl::xpath_query_impl* qimpl = impl::xpath_query_impl::create();
	12679	+
	12680	+ if (!qimpl)
	12681	+ {
	12682	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12683	+ _result.error = "Out of memory";
	12684	+ #else
	12685	+ throw std::bad_alloc();
	12686	+ #endif
	12687	+ }
	12688	+ else
	12689	+ {
	12690	+ using impl::auto_deleter; // MSVC7 workaround
	12691	+ auto_deleter<impl::xpath_query_impl> impl(qimpl, impl::xpath_query_impl::destroy);
	12692	+
	12693	+ qimpl->root = impl::xpath_parser::parse(query, variables, &qimpl->alloc, &_result);
	12694	+
	12695	+ if (qimpl->root)
	12696	+ {
	12697	+ qimpl->root->optimize(&qimpl->alloc);
	12698	+
	12699	+ _impl = impl.release();
	12700	+ _result.error = 0;
	12701	+ }
	12702	+ else
	12703	+ {
	12704	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12705	+ if (qimpl->oom) _result.error = "Out of memory";
	12706	+ #else
	12707	+ if (qimpl->oom) throw std::bad_alloc();
	12708	+ throw xpath_exception(_result);
	12709	+ #endif
	12710	+ }
	12711	+ }
	12712	+ }
	12713	+
	12714	+ PUGI__FN xpath_query::xpath_query(): _impl(0)
	12715	+ {
	12716	+ }
	12717	+
	12718	+ PUGI__FN xpath_query::~xpath_query()
	12719	+ {
	12720	+ if (_impl)
	12721	+ impl::xpath_query_impl::destroy(static_cast<impl::xpath_query_impl*>(_impl));
	12722	+ }
	12723	+
	12724	+#ifdef PUGIXML_HAS_MOVE
	12725	+ PUGI__FN xpath_query::xpath_query(xpath_query&& rhs) PUGIXML_NOEXCEPT
	12726	+ {
	12727	+ _impl = rhs._impl;
	12728	+ _result = rhs._result;
	12729	+ rhs._impl = 0;
	12730	+ rhs._result = xpath_parse_result();
	12731	+ }
	12732	+
	12733	+ PUGI__FN xpath_query& xpath_query::operator=(xpath_query&& rhs) PUGIXML_NOEXCEPT
	12734	+ {
	12735	+ if (this == &rhs) return *this;
	12736	+
	12737	+ if (_impl)
	12738	+ impl::xpath_query_impl::destroy(static_cast<impl::xpath_query_impl*>(_impl));
	12739	+
	12740	+ _impl = rhs._impl;
	12741	+ _result = rhs._result;
	12742	+ rhs._impl = 0;
	12743	+ rhs._result = xpath_parse_result();
	12744	+
	12745	+ return *this;
	12746	+ }
	12747	+#endif
	12748	+
	12749	+ PUGI__FN xpath_value_type xpath_query::return_type() const
	12750	+ {
	12751	+ if (!_impl) return xpath_type_none;
	12752	+
	12753	+ return static_cast<impl::xpath_query_impl*>(_impl)->root->rettype();
	12754	+ }
	12755	+
	12756	+ PUGI__FN bool xpath_query::evaluate_boolean(const xpath_node& n) const
	12757	+ {
	12758	+ if (!_impl) return false;
	12759	+
	12760	+ impl::xpath_context c(n, 1, 1);
	12761	+ impl::xpath_stack_data sd;
	12762	+
	12763	+ bool r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_boolean(c, sd.stack);
	12764	+
	12765	+ if (sd.oom)
	12766	+ {
	12767	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12768	+ return false;
	12769	+ #else
	12770	+ throw std::bad_alloc();
	12771	+ #endif
	12772	+ }
	12773	+
	12774	+ return r;
	12775	+ }
	12776	+
	12777	+ PUGI__FN double xpath_query::evaluate_number(const xpath_node& n) const
	12778	+ {
	12779	+ if (!_impl) return impl::gen_nan();
	12780	+
	12781	+ impl::xpath_context c(n, 1, 1);
	12782	+ impl::xpath_stack_data sd;
	12783	+
	12784	+ double r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_number(c, sd.stack);
	12785	+
	12786	+ if (sd.oom)
	12787	+ {
	12788	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12789	+ return impl::gen_nan();
	12790	+ #else
	12791	+ throw std::bad_alloc();
	12792	+ #endif
	12793	+ }
	12794	+
	12795	+ return r;
	12796	+ }
	12797	+
	12798	+#ifndef PUGIXML_NO_STL
	12799	+ PUGI__FN string_t xpath_query::evaluate_string(const xpath_node& n) const
	12800	+ {
	12801	+ if (!_impl) return string_t();
	12802	+
	12803	+ impl::xpath_context c(n, 1, 1);
	12804	+ impl::xpath_stack_data sd;
	12805	+
	12806	+ impl::xpath_string r = static_cast<impl::xpath_query_impl*>(_impl)->root->eval_string(c, sd.stack);
	12807	+
	12808	+ if (sd.oom)
	12809	+ {
	12810	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12811	+ return string_t();
	12812	+ #else
	12813	+ throw std::bad_alloc();
	12814	+ #endif
	12815	+ }
	12816	+
	12817	+ return string_t(r.c_str(), r.length());
	12818	+ }
	12819	+#endif
	12820	+
	12821	+ PUGI__FN size_t xpath_query::evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const
	12822	+ {
	12823	+ impl::xpath_context c(n, 1, 1);
	12824	+ impl::xpath_stack_data sd;
	12825	+
	12826	+ impl::xpath_string r = _impl ? static_cast<impl::xpath_query_impl*>(_impl)->root->eval_string(c, sd.stack) : impl::xpath_string();
	12827	+
	12828	+ if (sd.oom)
	12829	+ {
	12830	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12831	+ r = impl::xpath_string();
	12832	+ #else
	12833	+ throw std::bad_alloc();
	12834	+ #endif
	12835	+ }
	12836	+
	12837	+ size_t full_size = r.length() + 1;
	12838	+
	12839	+ if (capacity > 0)
	12840	+ {
	12841	+ size_t size = (full_size < capacity) ? full_size : capacity;
	12842	+ assert(size > 0);
	12843	+
	12844	+ memcpy(buffer, r.c_str(), (size - 1) * sizeof(char_t));
	12845	+ buffer[size - 1] = 0;
	12846	+ }
	12847	+
	12848	+ return full_size;
	12849	+ }
	12850	+
	12851	+ PUGI__FN xpath_node_set xpath_query::evaluate_node_set(const xpath_node& n) const
	12852	+ {
	12853	+ impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast<impl::xpath_query_impl*>(_impl));
	12854	+ if (!root) return xpath_node_set();
	12855	+
	12856	+ impl::xpath_context c(n, 1, 1);
	12857	+ impl::xpath_stack_data sd;
	12858	+
	12859	+ impl::xpath_node_set_raw r = root->eval_node_set(c, sd.stack, impl::nodeset_eval_all);
	12860	+
	12861	+ if (sd.oom)
	12862	+ {
	12863	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12864	+ return xpath_node_set();
	12865	+ #else
	12866	+ throw std::bad_alloc();
	12867	+ #endif
	12868	+ }
	12869	+
	12870	+ return xpath_node_set(r.begin(), r.end(), r.type());
	12871	+ }
	12872	+
	12873	+ PUGI__FN xpath_node xpath_query::evaluate_node(const xpath_node& n) const
	12874	+ {
	12875	+ impl::xpath_ast_node* root = impl::evaluate_node_set_prepare(static_cast<impl::xpath_query_impl*>(_impl));
	12876	+ if (!root) return xpath_node();
	12877	+
	12878	+ impl::xpath_context c(n, 1, 1);
	12879	+ impl::xpath_stack_data sd;
	12880	+
	12881	+ impl::xpath_node_set_raw r = root->eval_node_set(c, sd.stack, impl::nodeset_eval_first);
	12882	+
	12883	+ if (sd.oom)
	12884	+ {
	12885	+ #ifdef PUGIXML_NO_EXCEPTIONS
	12886	+ return xpath_node();
	12887	+ #else
	12888	+ throw std::bad_alloc();
	12889	+ #endif
	12890	+ }
	12891	+
	12892	+ return r.first();
	12893	+ }
	12894	+
	12895	+ PUGI__FN const xpath_parse_result& xpath_query::result() const
	12896	+ {
	12897	+ return _result;
	12898	+ }
	12899	+
	12900	+ PUGI__FN static void unspecified_bool_xpath_query(xpath_query***)
	12901	+ {
	12902	+ }
	12903	+
	12904	+ PUGI__FN xpath_query::operator xpath_query::unspecified_bool_type() const
	12905	+ {
	12906	+ return _impl ? unspecified_bool_xpath_query : 0;
	12907	+ }
	12908	+
	12909	+ PUGI__FN bool xpath_query::operator!() const
	12910	+ {
	12911	+ return !_impl;
	12912	+ }
	12913	+
	12914	+ PUGI__FN xpath_node xml_node::select_node(const char_t* query, xpath_variable_set* variables) const
	12915	+ {
	12916	+ xpath_query q(query, variables);
	12917	+ return q.evaluate_node(*this);
	12918	+ }
	12919	+
	12920	+ PUGI__FN xpath_node xml_node::select_node(const xpath_query& query) const
	12921	+ {
	12922	+ return query.evaluate_node(*this);
	12923	+ }
	12924	+
	12925	+ PUGI__FN xpath_node_set xml_node::select_nodes(const char_t* query, xpath_variable_set* variables) const
	12926	+ {
	12927	+ xpath_query q(query, variables);
	12928	+ return q.evaluate_node_set(*this);
	12929	+ }
	12930	+
	12931	+ PUGI__FN xpath_node_set xml_node::select_nodes(const xpath_query& query) const
	12932	+ {
	12933	+ return query.evaluate_node_set(*this);
	12934	+ }
	12935	+
	12936	+ PUGI__FN xpath_node xml_node::select_single_node(const char_t* query, xpath_variable_set* variables) const
	12937	+ {
	12938	+ xpath_query q(query, variables);
	12939	+ return q.evaluate_node(*this);
	12940	+ }
	12941	+
	12942	+ PUGI__FN xpath_node xml_node::select_single_node(const xpath_query& query) const
	12943	+ {
	12944	+ return query.evaluate_node(*this);
	12945	+ }
	12946	+}
	12947	+
	12948	+#endif
	12949	+
	12950	+#ifdef __BORLANDC__
	12951	+# pragma option pop
	12952	+#endif
	12953	+
	12954	+// Intel C++ does not properly keep warning state for function templates,
	12955	+// so popping warning state at the end of translation unit leads to warnings in the middle.
	12956	+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
	12957	+# pragma warning(pop)
	12958	+#endif
	12959	+
	12960	+#if defined(_MSC_VER) && defined(__c2__)
	12961	+# pragma clang diagnostic pop
	12962	+#endif
	12963	+
	12964	+// Undefine all local macros (makes sure we're not leaking macros in header-only mode)
	12965	+#undef PUGI__NO_INLINE
	12966	+#undef PUGI__UNLIKELY
	12967	+#undef PUGI__STATIC_ASSERT
	12968	+#undef PUGI__DMC_VOLATILE
	12969	+#undef PUGI__UNSIGNED_OVERFLOW
	12970	+#undef PUGI__MSVC_CRT_VERSION
	12971	+#undef PUGI__SNPRINTF
	12972	+#undef PUGI__NS_BEGIN
	12973	+#undef PUGI__NS_END
	12974	+#undef PUGI__FN
	12975	+#undef PUGI__FN_NO_INLINE
	12976	+#undef PUGI__GETHEADER_IMPL
	12977	+#undef PUGI__GETPAGE_IMPL
	12978	+#undef PUGI__GETPAGE
	12979	+#undef PUGI__NODETYPE
	12980	+#undef PUGI__IS_CHARTYPE_IMPL
	12981	+#undef PUGI__IS_CHARTYPE
	12982	+#undef PUGI__IS_CHARTYPEX
	12983	+#undef PUGI__ENDSWITH
	12984	+#undef PUGI__SKIPWS
	12985	+#undef PUGI__OPTSET
	12986	+#undef PUGI__PUSHNODE
	12987	+#undef PUGI__POPNODE
	12988	+#undef PUGI__SCANFOR
	12989	+#undef PUGI__SCANWHILE
	12990	+#undef PUGI__SCANWHILE_UNROLL
	12991	+#undef PUGI__ENDSEG
	12992	+#undef PUGI__THROW_ERROR
	12993	+#undef PUGI__CHECK_ERROR
	12994	+
	12995	+#endif
	12996	+
	12997	+/**
	12998	+ * Copyright (c) 2006-2020 Arseny Kapoulkine
	12999	+ *
	13000	+ * Permission is hereby granted, free of charge, to any person
	13001	+ * obtaining a copy of this software and associated documentation
	13002	+ * files (the "Software"), to deal in the Software without
	13003	+ * restriction, including without limitation the rights to use,
	13004	+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
	13005	+ * copies of the Software, and to permit persons to whom the
	13006	+ * Software is furnished to do so, subject to the following
	13007	+ * conditions:
	13008	+ *
	13009	+ * The above copyright notice and this permission notice shall be
	13010	+ * included in all copies or substantial portions of the Software.
	13011	+ *
	13012	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	13013	+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
	13014	+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	13015	+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
	13016	+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	13017	+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	13018	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	13019	+ * OTHER DEALINGS IN THE SOFTWARE.
	13020	+ */
...	...

src/pugixml.h 0 → 100644

View file @5b74613

	1	+++ a/src/pugixml.h
	1	+/**
	2	+ * pugixml parser - version 1.11
	3	+ * --------------------------------------------------------
	4	+ * Copyright (C) 2006-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
	5	+ * Report bugs and download new versions at https://pugixml.org/
	6	+ *
	7	+ * This library is distributed under the MIT License. See notice at the end
	8	+ * of this file.
	9	+ *
	10	+ * This work is based on the pugxml parser, which is:
	11	+ * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
	12	+ */
	13	+
	14	+#ifndef PUGIXML_VERSION
	15	+// Define version macro; evaluates to major * 1000 + minor * 10 + patch so that it's safe to use in less-than comparisons
	16	+// Note: pugixml used major * 100 + minor * 10 + patch format up until 1.9 (which had version identifier 190); starting from pugixml 1.10, the minor version number is two digits
	17	+# define PUGIXML_VERSION 1110
	18	+#endif
	19	+
	20	+// Include user configuration file (this can define various configuration macros)
	21	+#include "pugiconfig.h"
	22	+
	23	+#ifndef HEADER_PUGIXML_HPP
	24	+#define HEADER_PUGIXML_HPP
	25	+
	26	+// Include stddef.h for size_t and ptrdiff_t
	27	+#include <stddef.h>
	28	+
	29	+// Include exception header for XPath
	30	+#if !defined(PUGIXML_NO_XPATH) && !defined(PUGIXML_NO_EXCEPTIONS)
	31	+# include <exception>
	32	+#endif
	33	+
	34	+// Include STL headers
	35	+#ifndef PUGIXML_NO_STL
	36	+# include <iterator>
	37	+# include <iosfwd>
	38	+# include <string>
	39	+#endif
	40	+
	41	+// Macro for deprecated features
	42	+#ifndef PUGIXML_DEPRECATED
	43	+# if defined(__GNUC__)
	44	+# define PUGIXML_DEPRECATED __attribute__((deprecated))
	45	+# elif defined(_MSC_VER) && _MSC_VER >= 1300
	46	+# define PUGIXML_DEPRECATED __declspec(deprecated)
	47	+# else
	48	+# define PUGIXML_DEPRECATED
	49	+# endif
	50	+#endif
	51	+
	52	+// If no API is defined, assume default
	53	+#ifndef PUGIXML_API
	54	+# define PUGIXML_API
	55	+#endif
	56	+
	57	+// If no API for classes is defined, assume default
	58	+#ifndef PUGIXML_CLASS
	59	+# define PUGIXML_CLASS PUGIXML_API
	60	+#endif
	61	+
	62	+// If no API for functions is defined, assume default
	63	+#ifndef PUGIXML_FUNCTION
	64	+# define PUGIXML_FUNCTION PUGIXML_API
	65	+#endif
	66	+
	67	+// If the platform is known to have long long support, enable long long functions
	68	+#ifndef PUGIXML_HAS_LONG_LONG
	69	+# if __cplusplus >= 201103
	70	+# define PUGIXML_HAS_LONG_LONG
	71	+# elif defined(_MSC_VER) && _MSC_VER >= 1400
	72	+# define PUGIXML_HAS_LONG_LONG
	73	+# endif
	74	+#endif
	75	+
	76	+// If the platform is known to have move semantics support, compile move ctor/operator implementation
	77	+#ifndef PUGIXML_HAS_MOVE
	78	+# if __cplusplus >= 201103
	79	+# define PUGIXML_HAS_MOVE
	80	+# elif defined(_MSC_VER) && _MSC_VER >= 1600
	81	+# define PUGIXML_HAS_MOVE
	82	+# endif
	83	+#endif
	84	+
	85	+// If C++ is 2011 or higher, add 'noexcept' specifiers
	86	+#ifndef PUGIXML_NOEXCEPT
	87	+# if __cplusplus >= 201103
	88	+# define PUGIXML_NOEXCEPT noexcept
	89	+# elif defined(_MSC_VER) && _MSC_VER >= 1900
	90	+# define PUGIXML_NOEXCEPT noexcept
	91	+# else
	92	+# define PUGIXML_NOEXCEPT
	93	+# endif
	94	+#endif
	95	+
	96	+// Some functions can not be noexcept in compact mode
	97	+#ifdef PUGIXML_COMPACT
	98	+# define PUGIXML_NOEXCEPT_IF_NOT_COMPACT
	99	+#else
	100	+# define PUGIXML_NOEXCEPT_IF_NOT_COMPACT PUGIXML_NOEXCEPT
	101	+#endif
	102	+
	103	+// If C++ is 2011 or higher, add 'override' qualifiers
	104	+#ifndef PUGIXML_OVERRIDE
	105	+# if __cplusplus >= 201103
	106	+# define PUGIXML_OVERRIDE override
	107	+# elif defined(_MSC_VER) && _MSC_VER >= 1700
	108	+# define PUGIXML_OVERRIDE override
	109	+# else
	110	+# define PUGIXML_OVERRIDE
	111	+# endif
	112	+#endif
	113	+
	114	+// If C++ is 2011 or higher, use 'nullptr'
	115	+#ifndef PUGIXML_NULL
	116	+# if __cplusplus >= 201103
	117	+# define PUGIXML_NULL nullptr
	118	+# else
	119	+# define PUGIXML_NULL 0
	120	+# endif
	121	+#endif
	122	+
	123	+// Character interface macros
	124	+#ifdef PUGIXML_WCHAR_MODE
	125	+# define PUGIXML_TEXT(t) L ## t
	126	+# define PUGIXML_CHAR wchar_t
	127	+#else
	128	+# define PUGIXML_TEXT(t) t
	129	+# define PUGIXML_CHAR char
	130	+#endif
	131	+
	132	+namespace pugi
	133	+{
	134	+ // Character type used for all internal storage and operations; depends on PUGIXML_WCHAR_MODE
	135	+ typedef PUGIXML_CHAR char_t;
	136	+
	137	+#ifndef PUGIXML_NO_STL
	138	+ // String type used for operations that work with STL string; depends on PUGIXML_WCHAR_MODE
	139	+ typedef std::basic_string<PUGIXML_CHAR, std::char_traits<PUGIXML_CHAR>, std::allocator<PUGIXML_CHAR> > string_t;
	140	+#endif
	141	+}
	142	+
	143	+// The PugiXML namespace
	144	+namespace pugi
	145	+{
	146	+ // Tree node types
	147	+ enum xml_node_type
	148	+ {
	149	+ node_null, // Empty (null) node handle
	150	+ node_document, // A document tree's absolute root
	151	+ node_element, // Element tag, i.e. '<node/>'
	152	+ node_pcdata, // Plain character data, i.e. 'text'
	153	+ node_cdata, // Character data, i.e. '<![CDATA[text]]>'
	154	+ node_comment, // Comment tag, i.e. '<!-- text -->'
	155	+ node_pi, // Processing instruction, i.e. '<?name?>'
	156	+ node_declaration, // Document declaration, i.e. '<?xml version="1.0"?>'
	157	+ node_doctype // Document type declaration, i.e. '<!DOCTYPE doc>'
	158	+ };
	159	+
	160	+ // Parsing options
	161	+
	162	+ // Minimal parsing mode (equivalent to turning all other flags off).
	163	+ // Only elements and PCDATA sections are added to the DOM tree, no text conversions are performed.
	164	+ const unsigned int parse_minimal = 0x0000;
	165	+
	166	+ // This flag determines if processing instructions (node_pi) are added to the DOM tree. This flag is off by default.
	167	+ const unsigned int parse_pi = 0x0001;
	168	+
	169	+ // This flag determines if comments (node_comment) are added to the DOM tree. This flag is off by default.
	170	+ const unsigned int parse_comments = 0x0002;
	171	+
	172	+ // This flag determines if CDATA sections (node_cdata) are added to the DOM tree. This flag is on by default.
	173	+ const unsigned int parse_cdata = 0x0004;
	174	+
	175	+ // This flag determines if plain character data (node_pcdata) that consist only of whitespace are added to the DOM tree.
	176	+ // This flag is off by default; turning it on usually results in slower parsing and more memory consumption.
	177	+ const unsigned int parse_ws_pcdata = 0x0008;
	178	+
	179	+ // This flag determines if character and entity references are expanded during parsing. This flag is on by default.
	180	+ const unsigned int parse_escapes = 0x0010;
	181	+
	182	+ // This flag determines if EOL characters are normalized (converted to #xA) during parsing. This flag is on by default.
	183	+ const unsigned int parse_eol = 0x0020;
	184	+
	185	+ // This flag determines if attribute values are normalized using CDATA normalization rules during parsing. This flag is on by default.
	186	+ const unsigned int parse_wconv_attribute = 0x0040;
	187	+
	188	+ // This flag determines if attribute values are normalized using NMTOKENS normalization rules during parsing. This flag is off by default.
	189	+ const unsigned int parse_wnorm_attribute = 0x0080;
	190	+
	191	+ // This flag determines if document declaration (node_declaration) is added to the DOM tree. This flag is off by default.
	192	+ const unsigned int parse_declaration = 0x0100;
	193	+
	194	+ // This flag determines if document type declaration (node_doctype) is added to the DOM tree. This flag is off by default.
	195	+ const unsigned int parse_doctype = 0x0200;
	196	+
	197	+ // This flag determines if plain character data (node_pcdata) that is the only child of the parent node and that consists only
	198	+ // of whitespace is added to the DOM tree.
	199	+ // This flag is off by default; turning it on may result in slower parsing and more memory consumption.
	200	+ const unsigned int parse_ws_pcdata_single = 0x0400;
	201	+
	202	+ // This flag determines if leading and trailing whitespace is to be removed from plain character data. This flag is off by default.
	203	+ const unsigned int parse_trim_pcdata = 0x0800;
	204	+
	205	+ // This flag determines if plain character data that does not have a parent node is added to the DOM tree, and if an empty document
	206	+ // is a valid document. This flag is off by default.
	207	+ const unsigned int parse_fragment = 0x1000;
	208	+
	209	+ // This flag determines if plain character data is be stored in the parent element's value. This significantly changes the structure of
	210	+ // the document; this flag is only recommended for parsing documents with many PCDATA nodes in memory-constrained environments.
	211	+ // This flag is off by default.
	212	+ const unsigned int parse_embed_pcdata = 0x2000;
	213	+
	214	+ // The default parsing mode.
	215	+ // Elements, PCDATA and CDATA sections are added to the DOM tree, character/reference entities are expanded,
	216	+ // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
	217	+ const unsigned int parse_default = parse_cdata \| parse_escapes \| parse_wconv_attribute \| parse_eol;
	218	+
	219	+ // The full parsing mode.
	220	+ // Nodes of all types are added to the DOM tree, character/reference entities are expanded,
	221	+ // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
	222	+ const unsigned int parse_full = parse_default \| parse_pi \| parse_comments \| parse_declaration \| parse_doctype;
	223	+
	224	+ // These flags determine the encoding of input data for XML document
	225	+ enum xml_encoding
	226	+ {
	227	+ encoding_auto, // Auto-detect input encoding using BOM or < / <? detection; use UTF8 if BOM is not found
	228	+ encoding_utf8, // UTF8 encoding
	229	+ encoding_utf16_le, // Little-endian UTF16
	230	+ encoding_utf16_be, // Big-endian UTF16
	231	+ encoding_utf16, // UTF16 with native endianness
	232	+ encoding_utf32_le, // Little-endian UTF32
	233	+ encoding_utf32_be, // Big-endian UTF32
	234	+ encoding_utf32, // UTF32 with native endianness
	235	+ encoding_wchar, // The same encoding wchar_t has (either UTF16 or UTF32)
	236	+ encoding_latin1
	237	+ };
	238	+
	239	+ // Formatting flags
	240	+
	241	+ // Indent the nodes that are written to output stream with as many indentation strings as deep the node is in DOM tree. This flag is on by default.
	242	+ const unsigned int format_indent = 0x01;
	243	+
	244	+ // Write encoding-specific BOM to the output stream. This flag is off by default.
	245	+ const unsigned int format_write_bom = 0x02;
	246	+
	247	+ // Use raw output mode (no indentation and no line breaks are written). This flag is off by default.
	248	+ const unsigned int format_raw = 0x04;
	249	+
	250	+ // Omit default XML declaration even if there is no declaration in the document. This flag is off by default.
	251	+ const unsigned int format_no_declaration = 0x08;
	252	+
	253	+ // Don't escape attribute values and PCDATA contents. This flag is off by default.
	254	+ const unsigned int format_no_escapes = 0x10;
	255	+
	256	+ // 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.
	257	+ const unsigned int format_save_file_text = 0x20;
	258	+
	259	+ // Write every attribute on a new line with appropriate indentation. This flag is off by default.
	260	+ const unsigned int format_indent_attributes = 0x40;
	261	+
	262	+ // Don't output empty element tags, instead writing an explicit start and end tag even if there are no children. This flag is off by default.
	263	+ const unsigned int format_no_empty_element_tags = 0x80;
	264	+
	265	+ // Skip characters belonging to range [0; 32) instead of "&#xNN;" encoding. This flag is off by default.
	266	+ const unsigned int format_skip_control_chars = 0x100;
	267	+
	268	+ // Use single quotes ' instead of double quotes " for enclosing attribute values. This flag is off by default.
	269	+ const unsigned int format_attribute_single_quote = 0x200;
	270	+
	271	+ // The default set of formatting flags.
	272	+ // Nodes are indented depending on their depth in DOM tree, a default declaration is output if document has none.
	273	+ const unsigned int format_default = format_indent;
	274	+
	275	+ const int default_double_precision = 17;
	276	+ const int default_float_precision = 9;
	277	+
	278	+ // Forward declarations
	279	+ struct xml_attribute_struct;
	280	+ struct xml_node_struct;
	281	+
	282	+ class xml_node_iterator;
	283	+ class xml_attribute_iterator;
	284	+ class xml_named_node_iterator;
	285	+
	286	+ class xml_tree_walker;
	287	+
	288	+ struct xml_parse_result;
	289	+
	290	+ class xml_node;
	291	+
	292	+ class xml_text;
	293	+
	294	+ #ifndef PUGIXML_NO_XPATH
	295	+ class xpath_node;
	296	+ class xpath_node_set;
	297	+ class xpath_query;
	298	+ class xpath_variable_set;
	299	+ #endif
	300	+
	301	+ // Range-based for loop support
	302	+ template <typename It> class xml_object_range
	303	+ {
	304	+ public:
	305	+ typedef It const_iterator;
	306	+ typedef It iterator;
	307	+
	308	+ xml_object_range(It b, It e): _begin(b), _end(e)
	309	+ {
	310	+ }
	311	+
	312	+ It begin() const { return _begin; }
	313	+ It end() const { return _end; }
	314	+
	315	+ private:
	316	+ It _begin, _end;
	317	+ };
	318	+
	319	+ // Writer interface for node printing (see xml_node::print)
	320	+ class PUGIXML_CLASS xml_writer
	321	+ {
	322	+ public:
	323	+ virtual ~xml_writer() {}
	324	+
	325	+ // Write memory chunk into stream/file/whatever
	326	+ virtual void write(const void* data, size_t size) = 0;
	327	+ };
	328	+
	329	+ // xml_writer implementation for FILE*
	330	+ class PUGIXML_CLASS xml_writer_file: public xml_writer
	331	+ {
	332	+ public:
	333	+ // Construct writer from a FILE* object; void* is used to avoid header dependencies on stdio
	334	+ xml_writer_file(void* file);
	335	+
	336	+ // Deleted Copy contructor
	337	+ xml_writer_file( const xml_writer_file& ) = delete;
	338	+ // Deleted assignment operator
	339	+ xml_writer_file& operator=( const xml_writer_file& ) = delete;
	340	+ // Deleted move operator
	341	+ xml_writer_file( xml_writer_file&& ) = delete;
	342	+ // Deleted move operator
	343	+ xml_writer_file& operator=( xml_writer_file&& ) = delete;
	344	+
	345	+ virtual void write(const void* data, size_t size) PUGIXML_OVERRIDE;
	346	+
	347	+ private:
	348	+ void* file;
	349	+ };
	350	+
	351	+ #ifndef PUGIXML_NO_STL
	352	+ // xml_writer implementation for streams
	353	+ class PUGIXML_CLASS xml_writer_stream: public xml_writer
	354	+ {
	355	+ public:
	356	+ // Construct writer from an output stream object
	357	+ xml_writer_stream(std::basic_ostream<char, std::char_traits<char> >& stream);
	358	+ xml_writer_stream(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream);
	359	+
	360	+ // Deleted Copy contructor
	361	+ xml_writer_stream( const xml_writer_stream& ) = delete;
	362	+ // Deleted assignment operator
	363	+ xml_writer_stream& operator=( const xml_writer_stream& ) = delete;
	364	+ // Deleted move operator
	365	+ xml_writer_stream( xml_writer_stream&& ) = delete;
	366	+ // Deleted move operator
	367	+ xml_writer_stream& operator=( xml_writer_stream&& ) = delete;
	368	+
	369	+ virtual void write(const void* data, size_t size) PUGIXML_OVERRIDE;
	370	+
	371	+ private:
	372	+ std::basic_ostream<char, std::char_traits<char> >* narrow_stream;
	373	+ std::basic_ostream<wchar_t, std::char_traits<wchar_t> >* wide_stream;
	374	+ };
	375	+ #endif
	376	+
	377	+ // A light-weight handle for manipulating attributes in DOM tree
	378	+ class PUGIXML_CLASS xml_attribute
	379	+ {
	380	+ friend class xml_attribute_iterator;
	381	+ friend class xml_node;
	382	+
	383	+ private:
	384	+ xml_attribute_struct* _attr;
	385	+
	386	+ typedef void (unspecified_bool_type)(xml_attribute**);
	387	+
	388	+ public:
	389	+ // Default constructor. Constructs an empty attribute.
	390	+ xml_attribute();
	391	+
	392	+ // Constructs attribute from internal pointer
	393	+ explicit xml_attribute(xml_attribute_struct* attr);
	394	+
	395	+ // Safe bool conversion operator
	396	+ operator unspecified_bool_type() const;
	397	+
	398	+ // Borland C++ workaround
	399	+ bool operator!() const;
	400	+
	401	+ // Comparison operators (compares wrapped attribute pointers)
	402	+ bool operator==(const xml_attribute& r) const;
	403	+ bool operator!=(const xml_attribute& r) const;
	404	+ bool operator<(const xml_attribute& r) const;
	405	+ bool operator>(const xml_attribute& r) const;
	406	+ bool operator<=(const xml_attribute& r) const;
	407	+ bool operator>=(const xml_attribute& r) const;
	408	+
	409	+ // Check if attribute is empty
	410	+ bool empty() const;
	411	+
	412	+ // Get attribute name/value, or "" if attribute is empty
	413	+ const char_t* name() const;
	414	+ const char_t* value() const;
	415	+
	416	+ // Get attribute value, or the default value if attribute is empty
	417	+ const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
	418	+
	419	+ // Get attribute value as a number, or the default value if conversion did not succeed or attribute is empty
	420	+ int as_int(int def = 0) const;
	421	+ unsigned int as_uint(unsigned int def = 0) const;
	422	+ double as_double(double def = 0) const;
	423	+ float as_float(float def = 0) const;
	424	+
	425	+ #ifdef PUGIXML_HAS_LONG_LONG
	426	+ long long as_llong(long long def = 0) const;
	427	+ unsigned long long as_ullong(unsigned long long def = 0) const;
	428	+ #endif
	429	+
	430	+ // Get attribute value as bool (returns true if first character is in '1tTyY' set), or the default value if attribute is empty
	431	+ bool as_bool(bool def = false) const;
	432	+
	433	+ // Set attribute name/value (returns false if attribute is empty or there is not enough memory)
	434	+ bool set_name(const char_t* rhs);
	435	+ bool set_value(const char_t* rhs);
	436	+
	437	+ // Set attribute value with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
	438	+ bool set_value(int rhs);
	439	+ bool set_value(unsigned int rhs);
	440	+ bool set_value(long rhs);
	441	+ bool set_value(unsigned long rhs);
	442	+ bool set_value(double rhs);
	443	+ bool set_value(double rhs, int precision);
	444	+ bool set_value(float rhs);
	445	+ bool set_value(float rhs, int precision);
	446	+ bool set_value(bool rhs);
	447	+
	448	+ #ifdef PUGIXML_HAS_LONG_LONG
	449	+ bool set_value(long long rhs);
	450	+ bool set_value(unsigned long long rhs);
	451	+ #endif
	452	+
	453	+ // Set attribute value (equivalent to set_value without error checking)
	454	+ xml_attribute& operator=(const char_t* rhs);
	455	+ xml_attribute& operator=(int rhs);
	456	+ xml_attribute& operator=(unsigned int rhs);
	457	+ xml_attribute& operator=(long rhs);
	458	+ xml_attribute& operator=(unsigned long rhs);
	459	+ xml_attribute& operator=(double rhs);
	460	+ xml_attribute& operator=(float rhs);
	461	+ xml_attribute& operator=(bool rhs);
	462	+
	463	+ #ifdef PUGIXML_HAS_LONG_LONG
	464	+ xml_attribute& operator=(long long rhs);
	465	+ xml_attribute& operator=(unsigned long long rhs);
	466	+ #endif
	467	+
	468	+ // Get next/previous attribute in the attribute list of the parent node
	469	+ xml_attribute next_attribute() const;
	470	+ xml_attribute previous_attribute() const;
	471	+
	472	+ // Get hash value (unique for handles to the same object)
	473	+ size_t hash_value() const;
	474	+
	475	+ // Get internal pointer
	476	+ xml_attribute_struct* internal_object() const;
	477	+ };
	478	+
	479	+#ifdef __BORLANDC__
	480	+ // Borland C++ workaround
	481	+ bool PUGIXML_FUNCTION operator&&(const xml_attribute& lhs, bool rhs);
	482	+ bool PUGIXML_FUNCTION operator\|\|(const xml_attribute& lhs, bool rhs);
	483	+#endif
	484	+
	485	+ // A light-weight handle for manipulating nodes in DOM tree
	486	+ class PUGIXML_CLASS xml_node
	487	+ {
	488	+ friend class xml_attribute_iterator;
	489	+ friend class xml_node_iterator;
	490	+ friend class xml_named_node_iterator;
	491	+
	492	+ protected:
	493	+ xml_node_struct* _root;
	494	+
	495	+ typedef void (unspecified_bool_type)(xml_node**);
	496	+
	497	+ public:
	498	+ // Default constructor. Constructs an empty node.
	499	+ xml_node();
	500	+
	501	+ // Constructs node from internal pointer
	502	+ explicit xml_node(xml_node_struct* p);
	503	+
	504	+ // Safe bool conversion operator
	505	+ operator unspecified_bool_type() const;
	506	+
	507	+ // Borland C++ workaround
	508	+ bool operator!() const;
	509	+
	510	+ // Comparison operators (compares wrapped node pointers)
	511	+ bool operator==(const xml_node& r) const;
	512	+ bool operator!=(const xml_node& r) const;
	513	+ bool operator<(const xml_node& r) const;
	514	+ bool operator>(const xml_node& r) const;
	515	+ bool operator<=(const xml_node& r) const;
	516	+ bool operator>=(const xml_node& r) const;
	517	+
	518	+ // Check if node is empty.
	519	+ bool empty() const;
	520	+
	521	+ // Get node type
	522	+ xml_node_type type() const;
	523	+
	524	+ // Get node name, or "" if node is empty or it has no name
	525	+ const char_t* name() const;
	526	+
	527	+ // Get node value, or "" if node is empty or it has no value
	528	+ // Note: For <node>text</node> node.value() does not return "text"! Use child_value() or text() methods to access text inside nodes.
	529	+ const char_t* value() const;
	530	+
	531	+ // Get attribute list
	532	+ xml_attribute first_attribute() const;
	533	+ xml_attribute last_attribute() const;
	534	+
	535	+ // Get children list
	536	+ xml_node first_child() const;
	537	+ xml_node last_child() const;
	538	+
	539	+ // Get next/previous sibling in the children list of the parent node
	540	+ xml_node next_sibling() const;
	541	+ xml_node previous_sibling() const;
	542	+
	543	+ // Get parent node
	544	+ xml_node parent() const;
	545	+
	546	+ // Get root of DOM tree this node belongs to
	547	+ xml_node root() const;
	548	+
	549	+ // Get text object for the current node
	550	+ xml_text text() const;
	551	+
	552	+ // Get child, attribute or next/previous sibling with the specified name
	553	+ xml_node child(const char_t* name) const;
	554	+ xml_attribute attribute(const char_t* name) const;
	555	+ xml_node next_sibling(const char_t* name) const;
	556	+ xml_node previous_sibling(const char_t* name) const;
	557	+
	558	+ // Get attribute, starting the search from a hint (and updating hint so that searching for a sequence of attributes is fast)
	559	+ xml_attribute attribute(const char_t* name, xml_attribute& hint) const;
	560	+
	561	+ // Get child value of current node; that is, value of the first child node of type PCDATA/CDATA
	562	+ const char_t* child_value() const;
	563	+
	564	+ // Get child value of child with specified name. Equivalent to child(name).child_value().
	565	+ const char_t* child_value(const char_t* name) const;
	566	+
	567	+ // Set node name/value (returns false if node is empty, there is not enough memory, or node can not have name/value)
	568	+ bool set_name(const char_t* rhs);
	569	+ bool set_value(const char_t* rhs);
	570	+
	571	+ // Add attribute with specified name. Returns added attribute, or empty attribute on errors.
	572	+ xml_attribute append_attribute(const char_t* name);
	573	+ xml_attribute prepend_attribute(const char_t* name);
	574	+ xml_attribute insert_attribute_after(const char_t* name, const xml_attribute& attr);
	575	+ xml_attribute insert_attribute_before(const char_t* name, const xml_attribute& attr);
	576	+
	577	+ // Add a copy of the specified attribute. Returns added attribute, or empty attribute on errors.
	578	+ xml_attribute append_copy(const xml_attribute& proto);
	579	+ xml_attribute prepend_copy(const xml_attribute& proto);
	580	+ xml_attribute insert_copy_after(const xml_attribute& proto, const xml_attribute& attr);
	581	+ xml_attribute insert_copy_before(const xml_attribute& proto, const xml_attribute& attr);
	582	+
	583	+ // Add child node with specified type. Returns added node, or empty node on errors.
	584	+ xml_node append_child(xml_node_type type = node_element);
	585	+ xml_node prepend_child(xml_node_type type = node_element);
	586	+ xml_node insert_child_after(xml_node_type type, const xml_node& node);
	587	+ xml_node insert_child_before(xml_node_type type, const xml_node& node);
	588	+
	589	+ // Add child element with specified name. Returns added node, or empty node on errors.
	590	+ xml_node append_child(const char_t* name);
	591	+ xml_node prepend_child(const char_t* name);
	592	+ xml_node insert_child_after(const char_t* name, const xml_node& node);
	593	+ xml_node insert_child_before(const char_t* name, const xml_node& node);
	594	+
	595	+ // Add a copy of the specified node as a child. Returns added node, or empty node on errors.
	596	+ xml_node append_copy(const xml_node& proto);
	597	+ xml_node prepend_copy(const xml_node& proto);
	598	+ xml_node insert_copy_after(const xml_node& proto, const xml_node& node);
	599	+ xml_node insert_copy_before(const xml_node& proto, const xml_node& node);
	600	+
	601	+ // Move the specified node to become a child of this node. Returns moved node, or empty node on errors.
	602	+ xml_node append_move(const xml_node& moved);
	603	+ xml_node prepend_move(const xml_node& moved);
	604	+ xml_node insert_move_after(const xml_node& moved, const xml_node& node);
	605	+ xml_node insert_move_before(const xml_node& moved, const xml_node& node);
	606	+
	607	+ // Remove specified attribute
	608	+ bool remove_attribute(const xml_attribute& a);
	609	+ bool remove_attribute(const char_t* name);
	610	+
	611	+ // Remove all attributes
	612	+ bool remove_attributes();
	613	+
	614	+ // Remove specified child
	615	+ bool remove_child(const xml_node& n);
	616	+ bool remove_child(const char_t* name);
	617	+
	618	+ // Remove all children
	619	+ bool remove_children();
	620	+
	621	+ // Parses buffer as an XML document fragment and appends all nodes as children of the current node.
	622	+ // Copies/converts the buffer, so it may be deleted or changed after the function returns.
	623	+ // Note: append_buffer allocates memory that has the lifetime of the owning document; removing the appended nodes does not immediately reclaim that memory.
	624	+ xml_parse_result append_buffer(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
	625	+
	626	+ // Find attribute using predicate. Returns first attribute for which predicate returned true.
	627	+ template <typename Predicate> xml_attribute find_attribute(Predicate pred) const
	628	+ {
	629	+ if (!_root) return xml_attribute();
	630	+
	631	+ for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
	632	+ if (pred(attrib))
	633	+ return attrib;
	634	+
	635	+ return xml_attribute();
	636	+ }
	637	+
	638	+ // Find child node using predicate. Returns first child for which predicate returned true.
	639	+ template <typename Predicate> xml_node find_child(Predicate pred) const
	640	+ {
	641	+ if (!_root) return xml_node();
	642	+
	643	+ for (xml_node node = first_child(); node; node = node.next_sibling())
	644	+ if (pred(node))
	645	+ return node;
	646	+
	647	+ return xml_node();
	648	+ }
	649	+
	650	+ // Find node from subtree using predicate. Returns first node from subtree (depth-first), for which predicate returned true.
	651	+ template <typename Predicate> xml_node find_node(Predicate pred) const
	652	+ {
	653	+ if (!_root) return xml_node();
	654	+
	655	+ xml_node cur = first_child();
	656	+
	657	+ while (cur._root && cur._root != _root)
	658	+ {
	659	+ if (pred(cur)) return cur;
	660	+
	661	+ if (cur.first_child()) cur = cur.first_child();
	662	+ else if (cur.next_sibling()) cur = cur.next_sibling();
	663	+ else
	664	+ {
	665	+ while (!cur.next_sibling() && cur._root != _root) cur = cur.parent();
	666	+
	667	+ if (cur._root != _root) cur = cur.next_sibling();
	668	+ }
	669	+ }
	670	+
	671	+ return xml_node();
	672	+ }
	673	+
	674	+ // Find child node by attribute name/value
	675	+ xml_node find_child_by_attribute(const char_t* name, const char_t* attr_name, const char_t* attr_value) const;
	676	+ xml_node find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const;
	677	+
	678	+ #ifndef PUGIXML_NO_STL
	679	+ // Get the absolute node path from root as a text string.
	680	+ string_t path(char_t delimiter = '/') const;
	681	+ #endif
	682	+
	683	+ // Search for a node by path consisting of node names and . or .. elements.
	684	+ xml_node first_element_by_path(const char_t* path, char_t delimiter = '/') const;
	685	+
	686	+ // Recursively traverse subtree with xml_tree_walker
	687	+ bool traverse(xml_tree_walker& walker);
	688	+
	689	+ #ifndef PUGIXML_NO_XPATH
	690	+ // Select single node by evaluating XPath query. Returns first node from the resulting node set.
	691	+ xpath_node select_node(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;
	692	+ xpath_node select_node(const xpath_query& query) const;
	693	+
	694	+ // Select node set by evaluating XPath query
	695	+ xpath_node_set select_nodes(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;
	696	+ xpath_node_set select_nodes(const xpath_query& query) const;
	697	+
	698	+ // (deprecated: use select_node instead) Select single node by evaluating XPath query.
	699	+ PUGIXML_DEPRECATED xpath_node select_single_node(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL) const;
	700	+ PUGIXML_DEPRECATED xpath_node select_single_node(const xpath_query& query) const;
	701	+
	702	+ #endif
	703	+
	704	+ // Print subtree using a writer object
	705	+ void print(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;
	706	+
	707	+ #ifndef PUGIXML_NO_STL
	708	+ // Print subtree to stream
	709	+ void print(std::basic_ostream<char, std::char_traits<char> >& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;
	710	+ void print(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, unsigned int depth = 0) const;
	711	+ #endif
	712	+
	713	+ // Child nodes iterators
	714	+ typedef xml_node_iterator iterator;
	715	+
	716	+ iterator begin() const;
	717	+ iterator end() const;
	718	+
	719	+ // Attribute iterators
	720	+ typedef xml_attribute_iterator attribute_iterator;
	721	+
	722	+ attribute_iterator attributes_begin() const;
	723	+ attribute_iterator attributes_end() const;
	724	+
	725	+ // Range-based for support
	726	+ xml_object_range<xml_node_iterator> children() const;
	727	+ xml_object_range<xml_named_node_iterator> children(const char_t* name) const;
	728	+ xml_object_range<xml_attribute_iterator> attributes() const;
	729	+
	730	+ // Get node offset in parsed file/string (in char_t units) for debugging purposes
	731	+ ptrdiff_t offset_debug() const;
	732	+
	733	+ // Get hash value (unique for handles to the same object)
	734	+ size_t hash_value() const;
	735	+
	736	+ // Get internal pointer
	737	+ xml_node_struct* internal_object() const;
	738	+ };
	739	+
	740	+#ifdef __BORLANDC__
	741	+ // Borland C++ workaround
	742	+ bool PUGIXML_FUNCTION operator&&(const xml_node& lhs, bool rhs);
	743	+ bool PUGIXML_FUNCTION operator\|\|(const xml_node& lhs, bool rhs);
	744	+#endif
	745	+
	746	+ // A helper for working with text inside PCDATA nodes
	747	+ class PUGIXML_CLASS xml_text
	748	+ {
	749	+ friend class xml_node;
	750	+
	751	+ xml_node_struct* _root;
	752	+
	753	+ typedef void (unspecified_bool_type)(xml_text**);
	754	+
	755	+ explicit xml_text(xml_node_struct* root);
	756	+
	757	+ xml_node_struct* _data_new();
	758	+ xml_node_struct* _data() const;
	759	+
	760	+ public:
	761	+ // Default constructor. Constructs an empty object.
	762	+ xml_text();
	763	+
	764	+ // Safe bool conversion operator
	765	+ operator unspecified_bool_type() const;
	766	+
	767	+ // Borland C++ workaround
	768	+ bool operator!() const;
	769	+
	770	+ // Check if text object is empty
	771	+ bool empty() const;
	772	+
	773	+ // Get text, or "" if object is empty
	774	+ const char_t* get() const;
	775	+
	776	+ // Get text, or the default value if object is empty
	777	+ const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
	778	+
	779	+ // Get text as a number, or the default value if conversion did not succeed or object is empty
	780	+ int as_int(int def = 0) const;
	781	+ unsigned int as_uint(unsigned int def = 0) const;
	782	+ double as_double(double def = 0) const;
	783	+ float as_float(float def = 0) const;
	784	+
	785	+ #ifdef PUGIXML_HAS_LONG_LONG
	786	+ long long as_llong(long long def = 0) const;
	787	+ unsigned long long as_ullong(unsigned long long def = 0) const;
	788	+ #endif
	789	+
	790	+ // Get text as bool (returns true if first character is in '1tTyY' set), or the default value if object is empty
	791	+ bool as_bool(bool def = false) const;
	792	+
	793	+ // Set text (returns false if object is empty or there is not enough memory)
	794	+ bool set(const char_t* rhs);
	795	+
	796	+ // Set text with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
	797	+ bool set(int rhs);
	798	+ bool set(unsigned int rhs);
	799	+ bool set(long rhs);
	800	+ bool set(unsigned long rhs);
	801	+ bool set(double rhs);
	802	+ bool set(double rhs, int precision);
	803	+ bool set(float rhs);
	804	+ bool set(float rhs, int precision);
	805	+ bool set(bool rhs);
	806	+
	807	+ #ifdef PUGIXML_HAS_LONG_LONG
	808	+ bool set(long long rhs);
	809	+ bool set(unsigned long long rhs);
	810	+ #endif
	811	+
	812	+ // Set text (equivalent to set without error checking)
	813	+ xml_text& operator=(const char_t* rhs);
	814	+ xml_text& operator=(int rhs);
	815	+ xml_text& operator=(unsigned int rhs);
	816	+ xml_text& operator=(long rhs);
	817	+ xml_text& operator=(unsigned long rhs);
	818	+ xml_text& operator=(double rhs);
	819	+ xml_text& operator=(float rhs);
	820	+ xml_text& operator=(bool rhs);
	821	+
	822	+ #ifdef PUGIXML_HAS_LONG_LONG
	823	+ xml_text& operator=(long long rhs);
	824	+ xml_text& operator=(unsigned long long rhs);
	825	+ #endif
	826	+
	827	+ // Get the data node (node_pcdata or node_cdata) for this object
	828	+ xml_node data() const;
	829	+ };
	830	+
	831	+#ifdef __BORLANDC__
	832	+ // Borland C++ workaround
	833	+ bool PUGIXML_FUNCTION operator&&(const xml_text& lhs, bool rhs);
	834	+ bool PUGIXML_FUNCTION operator\|\|(const xml_text& lhs, bool rhs);
	835	+#endif
	836	+
	837	+ // Child node iterator (a bidirectional iterator over a collection of xml_node)
	838	+ class PUGIXML_CLASS xml_node_iterator
	839	+ {
	840	+ friend class xml_node;
	841	+
	842	+ private:
	843	+ mutable xml_node _wrap;
	844	+ xml_node _parent;
	845	+
	846	+ xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent);
	847	+
	848	+ public:
	849	+ // Iterator traits
	850	+ typedef ptrdiff_t difference_type;
	851	+ typedef xml_node value_type;
	852	+ typedef xml_node* pointer;
	853	+ typedef xml_node& reference;
	854	+
	855	+ #ifndef PUGIXML_NO_STL
	856	+ typedef std::bidirectional_iterator_tag iterator_category;
	857	+ #endif
	858	+
	859	+ // Default constructor
	860	+ xml_node_iterator();
	861	+
	862	+ // Construct an iterator which points to the specified node
	863	+ xml_node_iterator(const xml_node& node);
	864	+
	865	+ // Iterator operators
	866	+ bool operator==(const xml_node_iterator& rhs) const;
	867	+ bool operator!=(const xml_node_iterator& rhs) const;
	868	+
	869	+ xml_node& operator*() const;
	870	+ xml_node* operator->() const;
	871	+
	872	+ const xml_node_iterator& operator++();
	873	+ xml_node_iterator operator++(int);
	874	+
	875	+ const xml_node_iterator& operator--();
	876	+ xml_node_iterator operator--(int);
	877	+ };
	878	+
	879	+ // Attribute iterator (a bidirectional iterator over a collection of xml_attribute)
	880	+ class PUGIXML_CLASS xml_attribute_iterator
	881	+ {
	882	+ friend class xml_node;
	883	+
	884	+ private:
	885	+ mutable xml_attribute _wrap;
	886	+ xml_node _parent;
	887	+
	888	+ xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent);
	889	+
	890	+ public:
	891	+ // Iterator traits
	892	+ typedef ptrdiff_t difference_type;
	893	+ typedef xml_attribute value_type;
	894	+ typedef xml_attribute* pointer;
	895	+ typedef xml_attribute& reference;
	896	+
	897	+ #ifndef PUGIXML_NO_STL
	898	+ typedef std::bidirectional_iterator_tag iterator_category;
	899	+ #endif
	900	+
	901	+ // Default constructor
	902	+ xml_attribute_iterator();
	903	+
	904	+ // Construct an iterator which points to the specified attribute
	905	+ xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent);
	906	+
	907	+ // Iterator operators
	908	+ bool operator==(const xml_attribute_iterator& rhs) const;
	909	+ bool operator!=(const xml_attribute_iterator& rhs) const;
	910	+
	911	+ xml_attribute& operator*() const;
	912	+ xml_attribute* operator->() const;
	913	+
	914	+ const xml_attribute_iterator& operator++();
	915	+ xml_attribute_iterator operator++(int);
	916	+
	917	+ const xml_attribute_iterator& operator--();
	918	+ xml_attribute_iterator operator--(int);
	919	+ };
	920	+
	921	+ // Named node range helper
	922	+ class PUGIXML_CLASS xml_named_node_iterator
	923	+ {
	924	+ friend class xml_node;
	925	+
	926	+ public:
	927	+ // Iterator traits
	928	+ typedef ptrdiff_t difference_type;
	929	+ typedef xml_node value_type;
	930	+ typedef xml_node* pointer;
	931	+ typedef xml_node& reference;
	932	+
	933	+ #ifndef PUGIXML_NO_STL
	934	+ typedef std::bidirectional_iterator_tag iterator_category;
	935	+ #endif
	936	+
	937	+ // Default constructor
	938	+ xml_named_node_iterator();
	939	+
	940	+ // Construct an iterator which points to the specified node
	941	+ xml_named_node_iterator(const xml_node& node, const char_t* name);
	942	+
	943	+ // Iterator operators
	944	+ bool operator==(const xml_named_node_iterator& rhs) const;
	945	+ bool operator!=(const xml_named_node_iterator& rhs) const;
	946	+
	947	+ xml_node& operator*() const;
	948	+ xml_node* operator->() const;
	949	+
	950	+ const xml_named_node_iterator& operator++();
	951	+ xml_named_node_iterator operator++(int);
	952	+
	953	+ const xml_named_node_iterator& operator--();
	954	+ xml_named_node_iterator operator--(int);
	955	+
	956	+ private:
	957	+ mutable xml_node _wrap;
	958	+ xml_node _parent;
	959	+ const char_t* _name;
	960	+
	961	+ xml_named_node_iterator(xml_node_struct* ref, xml_node_struct* parent, const char_t* name);
	962	+ };
	963	+
	964	+ // Abstract tree walker class (see xml_node::traverse)
	965	+ class PUGIXML_CLASS xml_tree_walker
	966	+ {
	967	+ friend class xml_node;
	968	+
	969	+ private:
	970	+ int _depth;
	971	+
	972	+ protected:
	973	+ // Get current traversal depth
	974	+ int depth() const;
	975	+
	976	+ public:
	977	+ xml_tree_walker();
	978	+ virtual ~xml_tree_walker();
	979	+
	980	+ // Callback that is called when traversal begins
	981	+ virtual bool begin(xml_node& node);
	982	+
	983	+ // Callback that is called for each node traversed
	984	+ virtual bool for_each(xml_node& node) = 0;
	985	+
	986	+ // Callback that is called when traversal ends
	987	+ virtual bool end(xml_node& node);
	988	+ };
	989	+
	990	+ // Parsing status, returned as part of xml_parse_result object
	991	+ enum xml_parse_status
	992	+ {
	993	+ status_ok = 0, // No error
	994	+
	995	+ status_file_not_found, // File was not found during load_file()
	996	+ status_io_error, // Error reading from file/stream
	997	+ status_out_of_memory, // Could not allocate memory
	998	+ status_internal_error, // Internal error occurred
	999	+
	1000	+ status_unrecognized_tag, // Parser could not determine tag type
	1001	+
	1002	+ status_bad_pi, // Parsing error occurred while parsing document declaration/processing instruction
	1003	+ status_bad_comment, // Parsing error occurred while parsing comment
	1004	+ status_bad_cdata, // Parsing error occurred while parsing CDATA section
	1005	+ status_bad_doctype, // Parsing error occurred while parsing document type declaration
	1006	+ status_bad_pcdata, // Parsing error occurred while parsing PCDATA section
	1007	+ status_bad_start_element, // Parsing error occurred while parsing start element tag
	1008	+ status_bad_attribute, // Parsing error occurred while parsing element attribute
	1009	+ status_bad_end_element, // Parsing error occurred while parsing end element tag
	1010	+ status_end_element_mismatch,// There was a mismatch of start-end tags (closing tag had incorrect name, some tag was not closed or there was an excessive closing tag)
	1011	+
	1012	+ status_append_invalid_root, // Unable to append nodes since root type is not node_element or node_document (exclusive to xml_node::append_buffer)
	1013	+
	1014	+ status_no_document_element // Parsing resulted in a document without element nodes
	1015	+ };
	1016	+
	1017	+ // Parsing result
	1018	+ struct PUGIXML_CLASS xml_parse_result
	1019	+ {
	1020	+ // Parsing status (see xml_parse_status)
	1021	+ xml_parse_status status;
	1022	+
	1023	+ // Last parsed offset (in char_t units from start of input data)
	1024	+ ptrdiff_t offset;
	1025	+
	1026	+ // Source document encoding
	1027	+ xml_encoding encoding;
	1028	+
	1029	+ // Default constructor, initializes object to failed state
	1030	+ xml_parse_result();
	1031	+
	1032	+ // Cast to bool operator
	1033	+ operator bool() const;
	1034	+
	1035	+ // Get error description
	1036	+ const char* description() const;
	1037	+ };
	1038	+
	1039	+ // Document class (DOM tree root)
	1040	+ class PUGIXML_CLASS xml_document: public xml_node
	1041	+ {
	1042	+ private:
	1043	+ char_t* _buffer;
	1044	+
	1045	+ char _memory[192];
	1046	+
	1047	+ // Non-copyable semantics
	1048	+ xml_document(const xml_document&);
	1049	+ xml_document& operator=(const xml_document&);
	1050	+
	1051	+ void _create();
	1052	+ void _destroy();
	1053	+ void _move(xml_document& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;
	1054	+
	1055	+ public:
	1056	+ // Default constructor, makes empty document
	1057	+ xml_document();
	1058	+
	1059	+ // Destructor, invalidates all node/attribute handles to this document
	1060	+ ~xml_document();
	1061	+
	1062	+ #ifdef PUGIXML_HAS_MOVE
	1063	+ // Move semantics support
	1064	+ xml_document(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;
	1065	+ xml_document& operator=(xml_document&& rhs) PUGIXML_NOEXCEPT_IF_NOT_COMPACT;
	1066	+ #endif
	1067	+
	1068	+ // Removes all nodes, leaving the empty document
	1069	+ void reset();
	1070	+
	1071	+ // Removes all nodes, then copies the entire contents of the specified document
	1072	+ void reset(const xml_document& proto);
	1073	+
	1074	+ #ifndef PUGIXML_NO_STL
	1075	+ // Load document from stream.
	1076	+ xml_parse_result load(std::basic_istream<char, std::char_traits<char> >& stream, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
	1077	+ xml_parse_result load(std::basic_istream<wchar_t, std::char_traits<wchar_t> >& stream, unsigned int options = parse_default);
	1078	+ #endif
	1079	+
	1080	+ // (deprecated: use load_string instead) Load document from zero-terminated string. No encoding conversions are applied.
	1081	+ PUGIXML_DEPRECATED xml_parse_result load(const char_t* contents, unsigned int options = parse_default);
	1082	+
	1083	+ // Load document from zero-terminated string. No encoding conversions are applied.
	1084	+ xml_parse_result load_string(const char_t* contents, unsigned int options = parse_default);
	1085	+
	1086	+ // Load document from file
	1087	+ xml_parse_result load_file(const char* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
	1088	+ xml_parse_result load_file(const wchar_t* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
	1089	+
	1090	+ // Load document from buffer. Copies/converts the buffer, so it may be deleted or changed after the function returns.
	1091	+ xml_parse_result load_buffer(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
	1092	+
	1093	+ // Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
	1094	+ // You should ensure that buffer data will persist throughout the document's lifetime, and free the buffer memory manually once document is destroyed.
	1095	+ xml_parse_result load_buffer_inplace(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
	1096	+
	1097	+ // Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
	1098	+ // You should allocate the buffer with pugixml allocation function; document will free the buffer when it is no longer needed (you can't use it anymore).
	1099	+ xml_parse_result load_buffer_inplace_own(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
	1100	+
	1101	+ // Save XML document to writer (semantics is slightly different from xml_node::print, see documentation for details).
	1102	+ void save(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
	1103	+
	1104	+ #ifndef PUGIXML_NO_STL
	1105	+ // Save XML document to stream (semantics is slightly different from xml_node::print, see documentation for details).
	1106	+ void save(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
	1107	+ void save(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default) const;
	1108	+ #endif
	1109	+
	1110	+ // Save XML to file
	1111	+ bool save_file(const char* path, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
	1112	+ bool save_file(const wchar_t* path, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
	1113	+
	1114	+ // Get document element
	1115	+ xml_node document_element() const;
	1116	+ };
	1117	+
	1118	+#ifndef PUGIXML_NO_XPATH
	1119	+ // XPath query return type
	1120	+ enum xpath_value_type
	1121	+ {
	1122	+ xpath_type_none, // Unknown type (query failed to compile)
	1123	+ xpath_type_node_set, // Node set (xpath_node_set)
	1124	+ xpath_type_number, // Number
	1125	+ xpath_type_string, // String
	1126	+ xpath_type_boolean // Boolean
	1127	+ };
	1128	+
	1129	+ // XPath parsing result
	1130	+ struct PUGIXML_CLASS xpath_parse_result
	1131	+ {
	1132	+ // Error message (0 if no error)
	1133	+ const char* error;
	1134	+
	1135	+ // Last parsed offset (in char_t units from string start)
	1136	+ ptrdiff_t offset;
	1137	+
	1138	+ // Default constructor, initializes object to failed state
	1139	+ xpath_parse_result();
	1140	+
	1141	+ // Cast to bool operator
	1142	+ operator bool() const;
	1143	+
	1144	+ // Get error description
	1145	+ const char* description() const;
	1146	+ };
	1147	+
	1148	+ // A single XPath variable
	1149	+ class PUGIXML_CLASS xpath_variable
	1150	+ {
	1151	+ friend class xpath_variable_set;
	1152	+
	1153	+ protected:
	1154	+ xpath_value_type _type;
	1155	+ xpath_variable* _next;
	1156	+
	1157	+ xpath_variable(xpath_value_type type);
	1158	+
	1159	+ // Non-copyable semantics
	1160	+ xpath_variable(const xpath_variable&);
	1161	+ xpath_variable& operator=(const xpath_variable&);
	1162	+
	1163	+ public:
	1164	+ // Get variable name
	1165	+ const char_t* name() const;
	1166	+
	1167	+ // Get variable type
	1168	+ xpath_value_type type() const;
	1169	+
	1170	+ // Get variable value; no type conversion is performed, default value (false, NaN, empty string, empty node set) is returned on type mismatch error
	1171	+ bool get_boolean() const;
	1172	+ double get_number() const;
	1173	+ const char_t* get_string() const;
	1174	+ const xpath_node_set& get_node_set() const;
	1175	+
	1176	+ // Set variable value; no type conversion is performed, false is returned on type mismatch error
	1177	+ bool set(bool value);
	1178	+ bool set(double value);
	1179	+ bool set(const char_t* value);
	1180	+ bool set(const xpath_node_set& value);
	1181	+ };
	1182	+
	1183	+ // A set of XPath variables
	1184	+ class PUGIXML_CLASS xpath_variable_set
	1185	+ {
	1186	+ private:
	1187	+ xpath_variable* _data[64];
	1188	+
	1189	+ void _assign(const xpath_variable_set& rhs);
	1190	+ void _swap(xpath_variable_set& rhs);
	1191	+
	1192	+ xpath_variable* _find(const char_t* name) const;
	1193	+
	1194	+ static bool _clone(xpath_variable* var, xpath_variable** out_result);
	1195	+ static void _destroy(xpath_variable* var);
	1196	+
	1197	+ public:
	1198	+ // Default constructor/destructor
	1199	+ xpath_variable_set();
	1200	+ ~xpath_variable_set();
	1201	+
	1202	+ // Copy constructor/assignment operator
	1203	+ xpath_variable_set(const xpath_variable_set& rhs);
	1204	+ xpath_variable_set& operator=(const xpath_variable_set& rhs);
	1205	+
	1206	+ #ifdef PUGIXML_HAS_MOVE
	1207	+ // Move semantics support
	1208	+ xpath_variable_set(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT;
	1209	+ xpath_variable_set& operator=(xpath_variable_set&& rhs) PUGIXML_NOEXCEPT;
	1210	+ #endif
	1211	+
	1212	+ // Add a new variable or get the existing one, if the types match
	1213	+ xpath_variable* add(const char_t* name, xpath_value_type type);
	1214	+
	1215	+ // Set value of an existing variable; no type conversion is performed, false is returned if there is no such variable or if types mismatch
	1216	+ bool set(const char_t* name, bool value);
	1217	+ bool set(const char_t* name, double value);
	1218	+ bool set(const char_t* name, const char_t* value);
	1219	+ bool set(const char_t* name, const xpath_node_set& value);
	1220	+
	1221	+ // Get existing variable by name
	1222	+ xpath_variable* get(const char_t* name);
	1223	+ const xpath_variable* get(const char_t* name) const;
	1224	+ };
	1225	+
	1226	+ // A compiled XPath query object
	1227	+ class PUGIXML_CLASS xpath_query
	1228	+ {
	1229	+ private:
	1230	+ void* _impl;
	1231	+ xpath_parse_result _result;
	1232	+
	1233	+ typedef void (unspecified_bool_type)(xpath_query**);
	1234	+
	1235	+ // Non-copyable semantics
	1236	+ xpath_query(const xpath_query&);
	1237	+ xpath_query& operator=(const xpath_query&);
	1238	+
	1239	+ public:
	1240	+ // Construct a compiled object from XPath expression.
	1241	+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on compilation errors.
	1242	+ explicit xpath_query(const char_t* query, xpath_variable_set* variables = PUGIXML_NULL);
	1243	+
	1244	+ // Constructor
	1245	+ xpath_query();
	1246	+
	1247	+ // Destructor
	1248	+ ~xpath_query();
	1249	+
	1250	+ #ifdef PUGIXML_HAS_MOVE
	1251	+ // Move semantics support
	1252	+ xpath_query(xpath_query&& rhs) PUGIXML_NOEXCEPT;
	1253	+ xpath_query& operator=(xpath_query&& rhs) PUGIXML_NOEXCEPT;
	1254	+ #endif
	1255	+
	1256	+ // Get query expression return type
	1257	+ xpath_value_type return_type() const;
	1258	+
	1259	+ // Evaluate expression as boolean value in the specified context; performs type conversion if necessary.
	1260	+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
	1261	+ bool evaluate_boolean(const xpath_node& n) const;
	1262	+
	1263	+ // Evaluate expression as double value in the specified context; performs type conversion if necessary.
	1264	+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
	1265	+ double evaluate_number(const xpath_node& n) const;
	1266	+
	1267	+ #ifndef PUGIXML_NO_STL
	1268	+ // Evaluate expression as string value in the specified context; performs type conversion if necessary.
	1269	+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
	1270	+ string_t evaluate_string(const xpath_node& n) const;
	1271	+ #endif
	1272	+
	1273	+ // Evaluate expression as string value in the specified context; performs type conversion if necessary.
	1274	+ // At most capacity characters are written to the destination buffer, full result size is returned (includes terminating zero).
	1275	+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
	1276	+ // If PUGIXML_NO_EXCEPTIONS is defined, returns empty set instead.
	1277	+ size_t evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const;
	1278	+
	1279	+ // Evaluate expression as node set in the specified context.
	1280	+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on type mismatch and std::bad_alloc on out of memory errors.
	1281	+ // If PUGIXML_NO_EXCEPTIONS is defined, returns empty node set instead.
	1282	+ xpath_node_set evaluate_node_set(const xpath_node& n) const;
	1283	+
	1284	+ // Evaluate expression as node set in the specified context.
	1285	+ // Return first node in document order, or empty node if node set is empty.
	1286	+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on type mismatch and std::bad_alloc on out of memory errors.
	1287	+ // If PUGIXML_NO_EXCEPTIONS is defined, returns empty node instead.
	1288	+ xpath_node evaluate_node(const xpath_node& n) const;
	1289	+
	1290	+ // Get parsing result (used to get compilation errors in PUGIXML_NO_EXCEPTIONS mode)
	1291	+ const xpath_parse_result& result() const;
	1292	+
	1293	+ // Safe bool conversion operator
	1294	+ operator unspecified_bool_type() const;
	1295	+
	1296	+ // Borland C++ workaround
	1297	+ bool operator!() const;
	1298	+ };
	1299	+
	1300	+ #ifndef PUGIXML_NO_EXCEPTIONS
	1301	+ #if defined(_MSC_VER)
	1302	+ // C4275 can be ignored in Visual C++ if you are deriving
	1303	+ // from a type in the Standard C++ Library
	1304	+ #pragma warning(push)
	1305	+ #pragma warning(disable: 4275)
	1306	+ #endif
	1307	+ // XPath exception class
	1308	+ class PUGIXML_CLASS xpath_exception: public std::exception
	1309	+ {
	1310	+ private:
	1311	+ xpath_parse_result _result;
	1312	+
	1313	+ public:
	1314	+ // Construct exception from parse result
	1315	+ explicit xpath_exception(const xpath_parse_result& result);
	1316	+
	1317	+ // Get error message
	1318	+ virtual const char* what() const throw() PUGIXML_OVERRIDE;
	1319	+
	1320	+ // Get parse result
	1321	+ const xpath_parse_result& result() const;
	1322	+ };
	1323	+ #if defined(_MSC_VER)
	1324	+ #pragma warning(pop)
	1325	+ #endif
	1326	+ #endif
	1327	+
	1328	+ // XPath node class (either xml_node or xml_attribute)
	1329	+ class PUGIXML_CLASS xpath_node
	1330	+ {
	1331	+ private:
	1332	+ xml_node _node;
	1333	+ xml_attribute _attribute;
	1334	+
	1335	+ typedef void (unspecified_bool_type)(xpath_node**);
	1336	+
	1337	+ public:
	1338	+ // Default constructor; constructs empty XPath node
	1339	+ xpath_node();
	1340	+
	1341	+ // Construct XPath node from XML node/attribute
	1342	+ xpath_node(const xml_node& node);
	1343	+ xpath_node(const xml_attribute& attribute, const xml_node& parent);
	1344	+
	1345	+ // Get node/attribute, if any
	1346	+ xml_node node() const;
	1347	+ xml_attribute attribute() const;
	1348	+
	1349	+ // Get parent of contained node/attribute
	1350	+ xml_node parent() const;
	1351	+
	1352	+ // Safe bool conversion operator
	1353	+ operator unspecified_bool_type() const;
	1354	+
	1355	+ // Borland C++ workaround
	1356	+ bool operator!() const;
	1357	+
	1358	+ // Comparison operators
	1359	+ bool operator==(const xpath_node& n) const;
	1360	+ bool operator!=(const xpath_node& n) const;
	1361	+ };
	1362	+
	1363	+#ifdef __BORLANDC__
	1364	+ // Borland C++ workaround
	1365	+ bool PUGIXML_FUNCTION operator&&(const xpath_node& lhs, bool rhs);
	1366	+ bool PUGIXML_FUNCTION operator\|\|(const xpath_node& lhs, bool rhs);
	1367	+#endif
	1368	+
	1369	+ // A fixed-size collection of XPath nodes
	1370	+ class PUGIXML_CLASS xpath_node_set
	1371	+ {
	1372	+ public:
	1373	+ // Collection type
	1374	+ enum type_t
	1375	+ {
	1376	+ type_unsorted, // Not ordered
	1377	+ type_sorted, // Sorted by document order (ascending)
	1378	+ type_sorted_reverse // Sorted by document order (descending)
	1379	+ };
	1380	+
	1381	+ // Constant iterator type
	1382	+ typedef const xpath_node* const_iterator;
	1383	+
	1384	+ // We define non-constant iterator to be the same as constant iterator so that various generic algorithms (i.e. boost foreach) work
	1385	+ typedef const xpath_node* iterator;
	1386	+
	1387	+ // Default constructor. Constructs empty set.
	1388	+ xpath_node_set();
	1389	+
	1390	+ // Constructs a set from iterator range; data is not checked for duplicates and is not sorted according to provided type, so be careful
	1391	+ xpath_node_set(const_iterator begin, const_iterator end, type_t type = type_unsorted);
	1392	+
	1393	+ // Destructor
	1394	+ ~xpath_node_set();
	1395	+
	1396	+ // Copy constructor/assignment operator
	1397	+ xpath_node_set(const xpath_node_set& ns);
	1398	+ xpath_node_set& operator=(const xpath_node_set& ns);
	1399	+
	1400	+ #ifdef PUGIXML_HAS_MOVE
	1401	+ // Move semantics support
	1402	+ xpath_node_set(xpath_node_set&& rhs) PUGIXML_NOEXCEPT;
	1403	+ xpath_node_set& operator=(xpath_node_set&& rhs) PUGIXML_NOEXCEPT;
	1404	+ #endif
	1405	+
	1406	+ // Get collection type
	1407	+ type_t type() const;
	1408	+
	1409	+ // Get collection size
	1410	+ size_t size() const;
	1411	+
	1412	+ // Indexing operator
	1413	+ const xpath_node& operator[](size_t index) const;
	1414	+
	1415	+ // Collection iterators
	1416	+ const_iterator begin() const;
	1417	+ const_iterator end() const;
	1418	+
	1419	+ // Sort the collection in ascending/descending order by document order
	1420	+ void sort(bool reverse = false);
	1421	+
	1422	+ // Get first node in the collection by document order
	1423	+ xpath_node first() const;
	1424	+
	1425	+ // Check if collection is empty
	1426	+ bool empty() const;
	1427	+
	1428	+ private:
	1429	+ type_t _type;
	1430	+
	1431	+ xpath_node _storage[1];
	1432	+
	1433	+ xpath_node* _begin;
	1434	+ xpath_node* _end;
	1435	+
	1436	+ void _assign(const_iterator begin, const_iterator end, type_t type);
	1437	+ void _move(xpath_node_set& rhs) PUGIXML_NOEXCEPT;
	1438	+ };
	1439	+#endif
	1440	+
	1441	+#ifndef PUGIXML_NO_STL
	1442	+ // Convert wide string to UTF8
	1443	+ std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const wchar_t* str);
	1444	+ std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >& str);
	1445	+
	1446	+ // Convert UTF8 to wide string
	1447	+ std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const char* str);
	1448	+ std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >& str);
	1449	+#endif
	1450	+
	1451	+ // Memory allocation function interface; returns pointer to allocated memory or NULL on failure
	1452	+ typedef void* (*allocation_function)(size_t size);
	1453	+
	1454	+ // Memory deallocation function interface
	1455	+ typedef void (deallocation_function)(void ptr);
	1456	+
	1457	+ // Override default memory management functions. All subsequent allocations/deallocations will be performed via supplied functions.
	1458	+ void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate);
	1459	+
	1460	+ // Get current memory management functions
	1461	+ allocation_function PUGIXML_FUNCTION get_memory_allocation_function();
	1462	+ deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function();
	1463	+}
	1464	+
	1465	+#if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) \|\| defined(__ICC))
	1466	+namespace std
	1467	+{
	1468	+ // Workarounds for (non-standard) iterator category detection for older versions (MSVC7/IC8 and earlier)
	1469	+ std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_node_iterator&);
	1470	+ std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_attribute_iterator&);
	1471	+ std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_named_node_iterator&);
	1472	+}
	1473	+#endif
	1474	+
	1475	+#if !defined(PUGIXML_NO_STL) && defined(__SUNPRO_CC)
	1476	+namespace std
	1477	+{
	1478	+ // Workarounds for (non-standard) iterator category detection
	1479	+ std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_node_iterator&);
	1480	+ std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_attribute_iterator&);
	1481	+ std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_named_node_iterator&);
	1482	+}
	1483	+#endif
	1484	+
	1485	+#endif
	1486	+
	1487	+// Make sure implementation is included in header-only mode
	1488	+// Use macro expansion in #include to work around QMake (QTBUG-11923)
	1489	+#if defined(PUGIXML_HEADER_ONLY) && !defined(PUGIXML_SOURCE)
	1490	+# define PUGIXML_SOURCE "pugixml.cpp"
	1491	+# include PUGIXML_SOURCE
	1492	+#endif
	1493	+
	1494	+/**
	1495	+ * Copyright (c) 2006-2020 Arseny Kapoulkine
	1496	+ *
	1497	+ * Permission is hereby granted, free of charge, to any person
	1498	+ * obtaining a copy of this software and associated documentation
	1499	+ * files (the "Software"), to deal in the Software without
	1500	+ * restriction, including without limitation the rights to use,
	1501	+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
	1502	+ * copies of the Software, and to permit persons to whom the
	1503	+ * Software is furnished to do so, subject to the following
	1504	+ * conditions:
	1505	+ *
	1506	+ * The above copyright notice and this permission notice shall be
	1507	+ * included in all copies or substantial portions of the Software.
	1508	+ *
	1509	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	1510	+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
	1511	+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	1512	+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
	1513	+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	1514	+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	1515	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	1516	+ * OTHER DEALINGS IN THE SOFTWARE.
	1517	+ */
...	...

tests/CMakeLists.txt 0 → 100644

View file @5b74613

	1	+++ a/tests/CMakeLists.txt
	1	+cmake_minimum_required(VERSION 3.0)
	2	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../cmake)
	3	+
	4	+include(projectheader)
	5	+project_header(test_logutils)
	6	+
	7	+include_directories( SYSTEM
	8	+ ${CMAKE_CURRENT_SOURCE_DIR}/../../src
	9	+)
	10	+
	11	+include(compiler)
	12	+set(SRC_LIST
	13	+)
	14	+
	15	+# add_executable( ${PROJECT_NAME}
	16	+# ${SRC_LIST}
	17	+# )
	18	+
	19	+# target_link_libraries(
	20	+# ${PROJECT_NAME}
	21	+# )
	22	+
	23	+# set_target_properties( ${PROJECT_NAME} PROPERTIES
	24	+# RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
	25	+# LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
	26	+# ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/archive
	27	+# )
	28	+
	29	+# include(installation)
	30	+# install_application()
...	...