summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/pugixml.cpp1822
-rw-r--r--src/pugixml.hpp422
2 files changed, 1122 insertions, 1122 deletions
diff --git a/src/pugixml.cpp b/src/pugixml.cpp
index 80b8913..9530a4d 100644
--- a/src/pugixml.cpp
+++ b/src/pugixml.cpp
@@ -25,9 +25,9 @@
#ifndef PUGIXML_NO_XPATH
# include <math.h>
# include <float.h>
-# ifdef PUGIXML_NO_EXCEPTIONS
-# include <setjmp.h>
-# endif
+# ifdef PUGIXML_NO_EXCEPTIONS
+# include <setjmp.h>
+# endif
#endif
#ifndef PUGIXML_NO_STL
@@ -40,20 +40,20 @@
#include <new>
#ifdef _MSC_VER
-# pragma warning(push)
+# pragma warning(push)
# pragma warning(disable: 4127) // conditional expression is constant
# pragma warning(disable: 4324) // structure was padded due to __declspec(align())
# pragma warning(disable: 4611) // interaction between '_setjmp' and C++ object destruction is non-portable
# pragma warning(disable: 4702) // unreachable code
# pragma warning(disable: 4996) // this function or variable may be unsafe
-# pragma warning(disable: 4793) // function compiled as native: presence of '_setjmp' makes a function unmanaged
+# pragma warning(disable: 4793) // function compiled as native: presence of '_setjmp' makes a function unmanaged
#endif
#ifdef __INTEL_COMPILER
# pragma warning(disable: 177) // function was declared but never referenced
-# pragma warning(disable: 279) // controlling expression is constant
+# pragma warning(disable: 279) // controlling expression is constant
# pragma warning(disable: 1478 1786) // function was declared "deprecated"
-# pragma warning(disable: 1684) // conversion from pointer to same-sized integral type
+# pragma warning(disable: 1684) // conversion from pointer to same-sized integral type
#endif
#if defined(__BORLANDC__) && defined(PUGIXML_HEADER_ONLY)
@@ -61,13 +61,13 @@
#endif
#ifdef __BORLANDC__
-# pragma option push
+# pragma option push
# pragma warn -8008 // condition is always false
# pragma warn -8066 // unreachable code
#endif
#ifdef __SNC__
-# pragma diag_push
+# pragma diag_push
# pragma diag_suppress=178 // function was declared but never referenced
# pragma diag_suppress=237 // controlling expression is constant
#endif
@@ -103,20 +103,20 @@ using std::memmove;
#endif
#ifdef PUGIXML_HEADER_ONLY
-# define PUGI__NS_BEGIN namespace pugi { namespace impl {
-# define PUGI__NS_END } }
-# define PUGI__FN inline
-# define PUGI__FN_NO_INLINE inline
+# define PUGI__NS_BEGIN namespace pugi { namespace impl {
+# define PUGI__NS_END } }
+# define PUGI__FN inline
+# define PUGI__FN_NO_INLINE inline
#else
-# if defined(_MSC_VER) && _MSC_VER < 1300 // MSVC6 seems to have an amusing bug with anonymous namespaces inside namespaces
-# define PUGI__NS_BEGIN namespace pugi { namespace impl {
-# define PUGI__NS_END } }
-# else
-# define PUGI__NS_BEGIN namespace pugi { namespace impl { namespace {
-# define PUGI__NS_END } } }
-# endif
-# define PUGI__FN
-# define PUGI__FN_NO_INLINE PUGI__NO_INLINE
+# if defined(_MSC_VER) && _MSC_VER < 1300 // MSVC6 seems to have an amusing bug with anonymous namespaces inside namespaces
+# define PUGI__NS_BEGIN namespace pugi { namespace impl {
+# define PUGI__NS_END } }
+# else
+# define PUGI__NS_BEGIN namespace pugi { namespace impl { namespace {
+# define PUGI__NS_END } } }
+# endif
+# define PUGI__FN
+# define PUGI__FN_NO_INLINE PUGI__NO_INLINE
#endif
// uintptr_t
@@ -129,9 +129,9 @@ typedef size_t uintptr_t;
#define _UINTPTR_T_DEFINED
# endif
PUGI__NS_BEGIN
- typedef unsigned __int8 uint8_t;
- typedef unsigned __int16 uint16_t;
- typedef unsigned __int32 uint32_t;
+ typedef unsigned __int8 uint8_t;
+ typedef unsigned __int16 uint16_t;
+ typedef unsigned __int32 uint32_t;
PUGI__NS_END
#endif
@@ -147,17 +147,17 @@ PUGI__NS_BEGIN
free(ptr);
}
- template <typename T>
- struct xml_memory_management_function_storage
- {
- static allocation_function allocate;
- static deallocation_function deallocate;
- };
+ template <typename T>
+ struct xml_memory_management_function_storage
+ {
+ static allocation_function allocate;
+ static deallocation_function deallocate;
+ };
- template <typename T> allocation_function xml_memory_management_function_storage<T>::allocate = default_allocate;
- template <typename T> deallocation_function xml_memory_management_function_storage<T>::deallocate = default_deallocate;
+ template <typename T> allocation_function xml_memory_management_function_storage<T>::allocate = default_allocate;
+ template <typename T> deallocation_function xml_memory_management_function_storage<T>::deallocate = default_deallocate;
- typedef xml_memory_management_function_storage<int> xml_memory;
+ typedef xml_memory_management_function_storage<int> xml_memory;
PUGI__NS_END
// String utilities
@@ -235,12 +235,12 @@ PUGI__NS_END
PUGI__NS_BEGIN
static const size_t xml_memory_page_size =
- #ifdef PUGIXML_MEMORY_PAGE_SIZE
- PUGIXML_MEMORY_PAGE_SIZE
- #else
- 32768
- #endif
- ;
+ #ifdef PUGIXML_MEMORY_PAGE_SIZE
+ PUGIXML_MEMORY_PAGE_SIZE
+ #else
+ 32768
+ #endif
+ ;
static const uintptr_t xml_memory_page_alignment = 32;
static const uintptr_t xml_memory_page_pointer_mask = ~(xml_memory_page_alignment - 1);
@@ -391,15 +391,15 @@ PUGI__NS_BEGIN
assert(full_size < (1 << 16) || (page->busy_size == full_size && page_offset == 0));
header->full_size = static_cast<uint16_t>(full_size < (1 << 16) ? full_size : 0);
- // round-trip through void* to avoid 'cast increases required alignment of target type' warning
- // header is guaranteed a pointer-sized alignment, which should be enough for char_t
+ // round-trip through void* to avoid 'cast increases required alignment of target type' warning
+ // header is guaranteed a pointer-sized alignment, which should be enough for char_t
return static_cast<char_t*>(static_cast<void*>(header + 1));
}
void deallocate_string(char_t* string)
{
- // this function casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
- // we're guaranteed the proper (pointer-sized) alignment on the input string if it was allocated via allocate_string
+ // this function casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
+ // we're guaranteed the proper (pointer-sized) alignment on the input string if it was allocated via allocate_string
// get header
xml_memory_string_header* header = static_cast<xml_memory_string_header*>(static_cast<void*>(string)) - 1;
@@ -423,7 +423,7 @@ PUGI__NS_BEGIN
const size_t large_allocation_threshold = xml_memory_page_size / 4;
xml_memory_page* page = allocate_page(size <= large_allocation_threshold ? xml_memory_page_size : size);
- out_page = page;
+ out_page = page;
if (!page) return 0;
@@ -815,7 +815,7 @@ PUGI__NS_BEGIN
static value_type high(value_type result, uint32_t ch)
{
- (void)ch;
+ (void)ch;
*result = '?';
@@ -862,7 +862,7 @@ PUGI__NS_BEGIN
// process aligned single-byte (ascii) blocks
if ((reinterpret_cast<uintptr_t>(data) & 3) == 0)
{
- // round-trip through void* to silence 'cast increases required alignment of target type' warnings
+ // round-trip through void* to silence 'cast increases required alignment of target type' warnings
while (size >= 4 && (*static_cast<const uint32_t*>(static_cast<const void*>(data)) & 0x80808080) == 0)
{
result = Traits::low(result, data[0]);
@@ -978,27 +978,27 @@ PUGI__NS_BEGIN
static inline typename Traits::value_type decode_latin1_block(const uint8_t* data, size_t size, typename Traits::value_type result)
{
for (size_t i = 0; i < size; ++i)
- {
- result = Traits::low(result, data[i]);
- }
+ {
+ result = Traits::low(result, data[i]);
+ }
return result;
}
static inline typename Traits::value_type decode_wchar_block_impl(const uint16_t* data, size_t size, typename Traits::value_type result)
- {
- return decode_utf16_block(data, size, result);
- }
+ {
+ return decode_utf16_block(data, size, result);
+ }
static inline typename Traits::value_type decode_wchar_block_impl(const uint32_t* data, size_t size, typename Traits::value_type result)
- {
- return decode_utf32_block(data, size, result);
- }
+ {
+ return decode_utf32_block(data, size, result);
+ }
static inline typename Traits::value_type decode_wchar_block(const wchar_t* data, size_t size, typename Traits::value_type result)
- {
- return decode_wchar_block_impl(reinterpret_cast<const wchar_selector<sizeof(wchar_t)>::type*>(data), size, result);
- }
+ {
+ return decode_wchar_block_impl(reinterpret_cast<const wchar_selector<sizeof(wchar_t)>::type*>(data), size, result);
+ }
};
template <typename T> PUGI__FN void convert_utf_endian_swap(T* result, const T* data, size_t length)
@@ -1179,7 +1179,7 @@ PUGI__NS_BEGIN
PUGI__FN bool need_endian_swap_utf(xml_encoding le, xml_encoding re)
{
return (le == encoding_utf16_be && re == encoding_utf16_le) || (le == encoding_utf16_le && re == encoding_utf16_be) ||
- (le == encoding_utf32_be && re == encoding_utf32_le) || (le == encoding_utf32_le && re == encoding_utf32_be);
+ (le == encoding_utf32_be && re == encoding_utf32_le) || (le == encoding_utf32_le && re == encoding_utf32_be);
}
PUGI__FN bool convert_buffer_endian_swap(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
@@ -1323,7 +1323,7 @@ PUGI__NS_BEGIN
convert_buffer_utf32(out_buffer, out_length, contents, size, opt_true());
}
- // source encoding is latin1
+ // source encoding is latin1
if (encoding == encoding_latin1) return convert_buffer_latin1(out_buffer, out_length, contents, size);
assert(!"Invalid encoding");
@@ -1374,28 +1374,28 @@ PUGI__NS_BEGIN
return true;
}
- PUGI__FN size_t get_latin1_7bit_prefix_length(const uint8_t* data, size_t size)
- {
- for (size_t i = 0; i < size; ++i)
- if (data[i] > 127)
- return i;
+ PUGI__FN size_t get_latin1_7bit_prefix_length(const uint8_t* data, size_t size)
+ {
+ for (size_t i = 0; i < size; ++i)
+ if (data[i] > 127)
+ return i;
- return size;
- }
+ return size;
+ }
PUGI__FN bool convert_buffer_latin1(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
{
const uint8_t* data = static_cast<const uint8_t*>(contents);
- // get size of prefix that does not need utf8 conversion
- size_t prefix_length = get_latin1_7bit_prefix_length(data, size);
- assert(prefix_length <= size);
+ // get size of prefix that does not need utf8 conversion
+ size_t prefix_length = get_latin1_7bit_prefix_length(data, size);
+ assert(prefix_length <= size);
- const uint8_t* postfix = data + prefix_length;
- size_t postfix_length = size - prefix_length;
+ const uint8_t* postfix = data + prefix_length;
+ size_t postfix_length = size - prefix_length;
- // if no conversion is needed, just return the original buffer
- if (postfix_length == 0) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
+ // if no conversion is needed, just return the original buffer
+ if (postfix_length == 0) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
// first pass: get length in utf8 units
out_length = prefix_length + utf_decoder<utf8_counter>::decode_latin1_block(postfix, postfix_length, 0);
@@ -1405,7 +1405,7 @@ PUGI__NS_BEGIN
if (!out_buffer) return false;
// second pass: convert latin1 input to utf8
- memcpy(out_buffer, data, prefix_length);
+ memcpy(out_buffer, data, prefix_length);
uint8_t* out_begin = reinterpret_cast<uint8_t*>(out_buffer);
uint8_t* out_end = utf_decoder<utf8_writer>::decode_latin1_block(postfix, postfix_length, out_begin + prefix_length);
@@ -1441,7 +1441,7 @@ PUGI__NS_BEGIN
convert_buffer_utf32(out_buffer, out_length, contents, size, opt_true());
}
- // source encoding is latin1
+ // source encoding is latin1
if (encoding == encoding_latin1) return convert_buffer_latin1(out_buffer, out_length, contents, size, is_mutable);
assert(!"Invalid encoding");
@@ -1452,27 +1452,27 @@ PUGI__NS_BEGIN
PUGI__FN size_t as_utf8_begin(const wchar_t* str, size_t length)
{
// get length in utf8 characters
- return utf_decoder<utf8_counter>::decode_wchar_block(str, length, 0);
- }
-
- PUGI__FN void as_utf8_end(char* buffer, size_t size, const wchar_t* str, size_t length)
- {
- // convert to utf8
- uint8_t* begin = reinterpret_cast<uint8_t*>(buffer);
- uint8_t* end = utf_decoder<utf8_writer>::decode_wchar_block(str, length, begin);
-
- assert(begin + size == end);
- (void)!end;
+ return utf_decoder<utf8_counter>::decode_wchar_block(str, length, 0);
+ }
+
+ PUGI__FN void as_utf8_end(char* buffer, size_t size, const wchar_t* str, size_t length)
+ {
+ // convert to utf8
+ uint8_t* begin = reinterpret_cast<uint8_t*>(buffer);
+ uint8_t* end = utf_decoder<utf8_writer>::decode_wchar_block(str, length, begin);
+
+ assert(begin + size == end);
+ (void)!end;
// zero-terminate
buffer[size] = 0;
}
-
+
#ifndef PUGIXML_NO_STL
- PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length)
- {
+ PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length)
+ {
// first pass: get length in utf8 characters
- size_t size = as_utf8_begin(str, length);
+ size_t size = as_utf8_begin(str, length);
// allocate resulting string
std::string result;
@@ -1481,8 +1481,8 @@ PUGI__NS_BEGIN
// second pass: convert to utf8
if (size > 0) as_utf8_end(&result[0], size, str, length);
- return result;
- }
+ return result;
+ }
PUGI__FN std::basic_string<wchar_t> as_wide_impl(const char* str, size_t size)
{
@@ -1744,8 +1744,8 @@ PUGI__NS_BEGIN
break;
}
- default:
- break;
+ default:
+ break;
}
return stre;
@@ -2051,7 +2051,7 @@ PUGI__NS_BEGIN
{
xml_allocator alloc;
char_t* error_offset;
- xml_parse_status error_status;
+ xml_parse_status error_status;
// Parser utilities.
#define PUGI__SKIPWS() { while (PUGI__IS_CHARTYPE(*s, ct_space)) ++s; }
@@ -2119,7 +2119,7 @@ PUGI__NS_BEGIN
{
// nested ignore section
s = parse_doctype_ignore(s);
- if (!s) return s;
+ if (!s) return s;
}
else if (s[0] == ']' && s[1] == ']' && s[2] == '>')
{
@@ -2147,20 +2147,20 @@ PUGI__NS_BEGIN
{
// ignore
s = parse_doctype_ignore(s);
- if (!s) return s;
+ if (!s) return s;
}
else
{
// some control group
s = parse_doctype_group(s, endch, false);
- if (!s) return s;
+ if (!s) return s;
}
}
else if (s[0] == '<' || s[0] == '"' || s[0] == '\'')
{
// unknown tag (forbidden), or some primitive group
s = parse_doctype_primitive(s);
- if (!s) return s;
+ if (!s) return s;
}
else if (*s == '>')
{
@@ -2259,26 +2259,26 @@ PUGI__NS_BEGIN
{
s -= 2;
- if (cursor->parent) PUGI__THROW_ERROR(status_bad_doctype, s);
+ if (cursor->parent) PUGI__THROW_ERROR(status_bad_doctype, s);
- char_t* mark = s + 9;
+ char_t* mark = s + 9;
s = parse_doctype_group(s, endch, true);
- if (!s) return s;
+ if (!s) return s;
- if (PUGI__OPTSET(parse_doctype))
- {
- while (PUGI__IS_CHARTYPE(*mark, ct_space)) ++mark;
+ if (PUGI__OPTSET(parse_doctype))
+ {
+ while (PUGI__IS_CHARTYPE(*mark, ct_space)) ++mark;
- PUGI__PUSHNODE(node_doctype);
+ PUGI__PUSHNODE(node_doctype);
- cursor->value = mark;
+ cursor->value = mark;
- assert((s[0] == 0 && endch == '>') || s[-1] == '>');
- s[*s == 0 ? 0 : -1] = 0;
+ assert((s[0] == 0 && endch == '>') || s[-1] == '>');
+ s[*s == 0 ? 0 : -1] = 0;
- PUGI__POPNODE();
- }
+ PUGI__POPNODE();
+ }
}
else if (*s == 0 && endch == '-') PUGI__THROW_ERROR(status_bad_comment, s);
else if (*s == 0 && endch == '[') PUGI__THROW_ERROR(status_bad_cdata, s);
@@ -2412,8 +2412,8 @@ PUGI__NS_BEGIN
else if (PUGI__IS_CHARTYPE(ch, ct_space))
{
LOC_ATTRIBUTES:
- while (true)
- {
+ while (true)
+ {
PUGI__SKIPWS(); // Eat any whitespace.
if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // <... #...
@@ -2545,7 +2545,7 @@ PUGI__NS_BEGIN
else if (*s == '?') // '<?...'
{
s = parse_question(s, cursor, optmsk, endch);
- if (!s) return s;
+ if (!s) return s;
assert(cursor);
if ((cursor->header & xml_memory_page_type_mask) + 1 == node_declaration) goto LOC_ATTRIBUTES;
@@ -2553,7 +2553,7 @@ PUGI__NS_BEGIN
else if (*s == '!') // '<!...'
{
s = parse_exclamation(s, cursor, optmsk, endch);
- if (!s) return s;
+ if (!s) return s;
}
else if (*s == 0 && endch == '?') PUGI__THROW_ERROR(status_bad_pi, s);
else PUGI__THROW_ERROR(status_unrecognized_tag, s);
@@ -2564,20 +2564,20 @@ PUGI__NS_BEGIN
PUGI__SKIPWS(); // Eat whitespace if no genuine PCDATA here.
- if (*s == '<')
- {
- // We skipped some whitespace characters because otherwise we would take the tag branch instead of PCDATA one
- assert(mark != s);
-
- if (!PUGI__OPTSET(parse_ws_pcdata | parse_ws_pcdata_single))
- {
- continue;
- }
- else if (PUGI__OPTSET(parse_ws_pcdata_single))
- {
- if (s[1] != '/' || cursor->first_child) continue;
- }
- }
+ if (*s == '<')
+ {
+ // We skipped some whitespace characters because otherwise we would take the tag branch instead of PCDATA one
+ assert(mark != s);
+
+ if (!PUGI__OPTSET(parse_ws_pcdata | parse_ws_pcdata_single))
+ {
+ continue;
+ }
+ else if (PUGI__OPTSET(parse_ws_pcdata_single))
+ {
+ if (s[1] != '/' || cursor->first_child) continue;
+ }
+ }
s = mark;
@@ -2608,7 +2608,7 @@ PUGI__NS_BEGIN
// check that last tag is closed
if (cursor != xmldoc) PUGI__THROW_ERROR(status_end_element_mismatch, s);
- return s;
+ return s;
}
static xml_parse_result parse(char_t* buffer, size_t length, xml_node_struct* root, unsigned int optmsk)
@@ -2629,7 +2629,7 @@ PUGI__NS_BEGIN
buffer[length - 1] = 0;
// perform actual parsing
- parser.parse(buffer, xmldoc, optmsk, endch);
+ parser.parse(buffer, xmldoc, optmsk, endch);
xml_parse_result result = make_parse_result(parser.error_status, parser.error_offset ? parser.error_offset - buffer : 0);
assert(result.offset >= 0 && static_cast<size_t>(result.offset) <= length);
@@ -2818,7 +2818,7 @@ PUGI__NS_BEGIN
public:
xml_buffered_writer(xml_writer& writer_, xml_encoding user_encoding): writer(writer_), bufsize(0), encoding(get_write_encoding(user_encoding))
{
- PUGI__STATIC_ASSERT(bufcapacity >= 8);
+ PUGI__STATIC_ASSERT(bufcapacity >= 8);
}
~xml_buffered_writer()
@@ -2963,26 +2963,26 @@ PUGI__NS_BEGIN
// utf16 maximum expansion: x2 (-> utf32)
// utf32 maximum expansion: x1
enum
- {
- bufcapacitybytes =
- #ifdef PUGIXML_MEMORY_OUTPUT_STACK
- PUGIXML_MEMORY_OUTPUT_STACK
- #else
- 10240
- #endif
- ,
- bufcapacity = bufcapacitybytes / (sizeof(char_t) + 4)
- };
+ {
+ bufcapacitybytes =
+ #ifdef PUGIXML_MEMORY_OUTPUT_STACK
+ PUGIXML_MEMORY_OUTPUT_STACK
+ #else
+ 10240
+ #endif
+ ,
+ bufcapacity = bufcapacitybytes / (sizeof(char_t) + 4)
+ };
char_t buffer[bufcapacity];
- union
- {
- uint8_t data_u8[4 * bufcapacity];
- uint16_t data_u16[2 * bufcapacity];
- uint32_t data_u32[bufcapacity];
- char_t data_char[bufcapacity];
- } scratch;
+ union
+ {
+ uint8_t data_u8[4 * bufcapacity];
+ uint16_t data_u16[2 * bufcapacity];
+ uint32_t data_u32[bufcapacity];
+ char_t data_char[bufcapacity];
+ } scratch;
xml_writer& writer;
size_t bufsize;
@@ -3031,12 +3031,12 @@ PUGI__NS_BEGIN
}
PUGI__FN void text_output(xml_buffered_writer& writer, const char_t* s, chartypex_t type, unsigned int flags)
- {
- if (flags & format_no_escapes)
- writer.write(s);
- else
- text_output_escaped(writer, s, type);
- }
+ {
+ if (flags & format_no_escapes)
+ writer.write(s);
+ else
+ text_output_escaped(writer, s, type);
+ }
PUGI__FN void text_output_cdata(xml_buffered_writer& writer, const char_t* s)
{
@@ -3070,7 +3070,7 @@ PUGI__NS_BEGIN
writer.write(a.name()[0] ? a.name() : default_name);
writer.write('=', '"');
- text_output(writer, a.value(), ctx_special_attr, flags);
+ text_output(writer, a.value(), ctx_special_attr, flags);
writer.write('"');
}
@@ -3123,10 +3123,10 @@ PUGI__NS_BEGIN
{
writer.write('>');
- if (node.first_child().type() == node_pcdata)
- text_output(writer, node.first_child().value(), ctx_special_pcdata, flags);
- else
- text_output_cdata(writer, node.first_child().value());
+ if (node.first_child().type() == node_pcdata)
+ text_output(writer, node.first_child().value(), ctx_special_pcdata, flags);
+ else
+ text_output_cdata(writer, node.first_child().value());
writer.write('<', '/');
writer.write(name);
@@ -3190,13 +3190,13 @@ PUGI__NS_BEGIN
writer.write('<', '!', 'D', 'O', 'C');
writer.write('T', 'Y', 'P', 'E');
- if (node.value()[0])
- {
- writer.write(' ');
- writer.write(node.value());
- }
+ if (node.value()[0])
+ {
+ writer.write(' ');
+ writer.write(node.value());
+ }
- writer.write('>');
+ writer.write('>');
if ((flags & format_raw) == 0) writer.write('\n');
break;
@@ -3256,7 +3256,7 @@ PUGI__NS_BEGIN
case node_pcdata:
case node_cdata:
case node_comment:
- case node_doctype:
+ case node_doctype:
dest.set_value(source.value());
break;
@@ -3280,17 +3280,17 @@ PUGI__NS_BEGIN
}
}
- inline bool is_text_node(xml_node_struct* node)
- {
- xml_node_type type = static_cast<xml_node_type>((node->header & impl::xml_memory_page_type_mask) + 1);
+ inline bool is_text_node(xml_node_struct* node)
+ {
+ xml_node_type type = static_cast<xml_node_type>((node->header & impl::xml_memory_page_type_mask) + 1);
- return type == node_pcdata || type == node_cdata;
- }
+ return type == node_pcdata || type == node_cdata;
+ }
- // get value with conversion functions
+ // get value with conversion functions
PUGI__FN int get_value_int(const char_t* value, int def)
{
- if (!value) return def;
+ if (!value) return def;
#ifdef PUGIXML_WCHAR_MODE
return static_cast<int>(wcstol(value, 0, 10));
@@ -3301,7 +3301,7 @@ PUGI__NS_BEGIN
PUGI__FN unsigned int get_value_uint(const char_t* value, unsigned int def)
{
- if (!value) return def;
+ if (!value) return def;
#ifdef PUGIXML_WCHAR_MODE
return static_cast<unsigned int>(wcstoul(value, 0, 10));
@@ -3312,7 +3312,7 @@ PUGI__NS_BEGIN
PUGI__FN double get_value_double(const char_t* value, double def)
{
- if (!value) return def;
+ if (!value) return def;
#ifdef PUGIXML_WCHAR_MODE
return wcstod(value, 0);
@@ -3323,7 +3323,7 @@ PUGI__NS_BEGIN
PUGI__FN float get_value_float(const char_t* value, float def)
{
- if (!value) return def;
+ if (!value) return def;
#ifdef PUGIXML_WCHAR_MODE
return static_cast<float>(wcstod(value, 0));
@@ -3334,7 +3334,7 @@ PUGI__NS_BEGIN
PUGI__FN bool get_value_bool(const char_t* value, bool def)
{
- if (!value) return def;
+ if (!value) return def;
// only look at first char
char_t first = *value;
@@ -3343,9 +3343,9 @@ PUGI__NS_BEGIN
return (first == '1' || first == 't' || first == 'T' || first == 'y' || first == 'Y');
}
- // set value with conversion functions
+ // set value with conversion functions
PUGI__FN bool set_value_buffer(char_t*& dest, uintptr_t& header, uintptr_t header_mask, char (&buf)[128])
- {
+ {
#ifdef PUGIXML_WCHAR_MODE
char_t wbuf[128];
impl::widen_ascii(wbuf, buf);
@@ -3354,22 +3354,22 @@ PUGI__NS_BEGIN
#else
return strcpy_insitu(dest, header, header_mask, buf);
#endif
- }
+ }
PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, int value)
- {
+ {
char buf[128];
sprintf(buf, "%d", value);
- return set_value_buffer(dest, header, header_mask, buf);
- }
+ return set_value_buffer(dest, header, header_mask, buf);
+ }
PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, unsigned int value)
{
char buf[128];
sprintf(buf, "%u", value);
- return set_value_buffer(dest, header, header_mask, buf);
+ return set_value_buffer(dest, header, header_mask, buf);
}
PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, double value)
@@ -3377,7 +3377,7 @@ PUGI__NS_BEGIN
char buf[128];
sprintf(buf, "%g", value);
- return set_value_buffer(dest, header, header_mask, buf);
+ return set_value_buffer(dest, header, header_mask, buf);
}
PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, bool value)
@@ -3462,89 +3462,89 @@ PUGI__NS_BEGIN
}
#ifndef PUGIXML_NO_STL
- template <typename T> struct xml_stream_chunk
- {
- static xml_stream_chunk* create()
- {
- void* memory = xml_memory::allocate(sizeof(xml_stream_chunk));
-
- return new (memory) xml_stream_chunk();
- }
-
- static void destroy(void* ptr)
- {
- xml_stream_chunk* chunk = static_cast<xml_stream_chunk*>(ptr);
-
- // free chunk chain
- while (chunk)
- {
- xml_stream_chunk* next = chunk->next;
- xml_memory::deallocate(chunk);
- chunk = next;
- }
- }
-
- xml_stream_chunk(): next(0), size(0)
- {
- }
-
- xml_stream_chunk* next;
- size_t size;
-
- T data[xml_memory_page_size / sizeof(T)];
- };
+ template <typename T> struct xml_stream_chunk
+ {
+ static xml_stream_chunk* create()
+ {
+ void* memory = xml_memory::allocate(sizeof(xml_stream_chunk));
+
+ return new (memory) xml_stream_chunk();
+ }
+
+ static void destroy(void* ptr)
+ {
+ xml_stream_chunk* chunk = static_cast<xml_stream_chunk*>(ptr);
+
+ // free chunk chain
+ while (chunk)
+ {
+ xml_stream_chunk* next = chunk->next;
+ xml_memory::deallocate(chunk);
+ chunk = next;
+ }
+ }
+
+ xml_stream_chunk(): next(0), size(0)
+ {
+ }
+
+ xml_stream_chunk* next;
+ size_t size;
+
+ T data[xml_memory_page_size / sizeof(T)];
+ };
template <typename T> PUGI__FN xml_parse_status load_stream_data_noseek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
- {
- buffer_holder chunks(0, xml_stream_chunk<T>::destroy);
+ {
+ buffer_holder chunks(0, xml_stream_chunk<T>::destroy);
- // read file to a chunk list
- size_t total = 0;
- xml_stream_chunk<T>* last = 0;
+ // read file to a chunk list
+ size_t total = 0;
+ xml_stream_chunk<T>* last = 0;
- while (!stream.eof())
- {
- // allocate new chunk
- xml_stream_chunk<T>* chunk = xml_stream_chunk<T>::create();
- if (!chunk) return status_out_of_memory;
+ while (!stream.eof())
+ {
+ // allocate new chunk
+ xml_stream_chunk<T>* chunk = xml_stream_chunk<T>::create();
+ if (!chunk) return status_out_of_memory;
- // append chunk to list
- if (last) last = last->next = chunk;
- else chunks.data = last = chunk;
+ // append chunk to list
+ if (last) last = last->next = chunk;
+ else chunks.data = last = chunk;
- // read data to chunk
- stream.read(chunk->data, static_cast<std::streamsize>(sizeof(chunk->data) / sizeof(T)));
- chunk->size = static_cast<size_t>(stream.gcount()) * sizeof(T);
+ // read data to chunk
+ stream.read(chunk->data, static_cast<std::streamsize>(sizeof(chunk->data) / sizeof(T)));
+ chunk->size = static_cast<size_t>(stream.gcount()) * sizeof(T);
- // read may set failbit | eofbit in case gcount() is less than read length, so check for other I/O errors
- if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
+ // read may set failbit | eofbit in case gcount() is less than read length, so check for other I/O errors
+ if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
- // guard against huge files (chunk size is small enough to make this overflow check work)
- if (total + chunk->size < total) return status_out_of_memory;
- total += chunk->size;
- }
+ // guard against huge files (chunk size is small enough to make this overflow check work)
+ if (total + chunk->size < total) return status_out_of_memory;
+ total += chunk->size;
+ }
- // copy chunk list to a contiguous buffer
- char* buffer = static_cast<char*>(xml_memory::allocate(total));
- if (!buffer) return status_out_of_memory;
+ // copy chunk list to a contiguous buffer
+ char* buffer = static_cast<char*>(xml_memory::allocate(total));
+ if (!buffer) return status_out_of_memory;
- char* write = buffer;
+ char* write = buffer;
- for (xml_stream_chunk<T>* chunk = static_cast<xml_stream_chunk<T>*>(chunks.data); chunk; chunk = chunk->next)
- {
- assert(write + chunk->size <= buffer + total);
- memcpy(write, chunk->data, chunk->size);
- write += chunk->size;
- }
+ for (xml_stream_chunk<T>* chunk = static_cast<xml_stream_chunk<T>*>(chunks.data); chunk; chunk = chunk->next)
+ {
+ assert(write + chunk->size <= buffer + total);
+ memcpy(write, chunk->data, chunk->size);
+ write += chunk->size;
+ }
- assert(write == buffer + total);
+ assert(write == buffer + total);
- // return buffer
- *out_buffer = buffer;
- *out_size = total;
+ // return buffer
+ *out_buffer = buffer;
+ *out_size = total;
- return status_ok;
- }
+ return status_ok;
+ }
template <typename T> PUGI__FN xml_parse_status load_stream_data_seek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
{
@@ -3568,29 +3568,29 @@ PUGI__NS_BEGIN
stream.read(static_cast<T*>(buffer.data), static_cast<std::streamsize>(read_length));
// read may set failbit | eofbit in case gcount() is less than read_length (i.e. line ending conversion), so check for other I/O errors
- if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
+ if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
// return buffer
size_t actual_length = static_cast<size_t>(stream.gcount());
assert(actual_length <= read_length);
- *out_buffer = buffer.release();
- *out_size = actual_length * sizeof(T);
+ *out_buffer = buffer.release();
+ *out_size = actual_length * sizeof(T);
- return status_ok;
+ return status_ok;
}
template <typename T> PUGI__FN xml_parse_result load_stream_impl(xml_document& doc, std::basic_istream<T>& stream, unsigned int options, xml_encoding encoding)
{
- void* buffer = 0;
- size_t size = 0;
+ void* buffer = 0;
+ size_t size = 0;
- // load stream to memory (using seek-based implementation if possible, since it's faster and takes less memory)
- xml_parse_status status = (stream.tellg() < 0) ? load_stream_data_noseek(stream, &buffer, &size) : load_stream_data_seek(stream, &buffer, &size);
- if (status != status_ok) return make_parse_result(status);
+ // load stream to memory (using seek-based implementation if possible, since it's faster and takes less memory)
+ xml_parse_status status = (stream.tellg() < 0) ? load_stream_data_noseek(stream, &buffer, &size) : load_stream_data_seek(stream, &buffer, &size);
+ if (status != status_ok) return make_parse_result(status);
return doc.load_buffer_inplace_own(buffer, size, options, encoding);
- }
+ }
#endif
#if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__) || (defined(__MINGW32__) && !defined(__STRICT_ANSI__))
@@ -3605,16 +3605,16 @@ PUGI__NS_BEGIN
// first pass: get length in utf8 characters
size_t length = wcslen(str);
- size_t size = as_utf8_begin(str, length);
+ size_t size = as_utf8_begin(str, length);
// allocate resulting string
char* result = static_cast<char*>(xml_memory::allocate(size + 1));
if (!result) return 0;
// second pass: convert to utf8
- as_utf8_end(result, size, str, length);
+ as_utf8_end(result, size, str, length);
- return result;
+ return result;
}
PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
@@ -3644,7 +3644,7 @@ PUGI__NS_BEGIN
xml_writer_file writer(file);
doc.save(writer, indent, flags, encoding);
- int result = ferror(file);
+ int result = ferror(file);
fclose(file);
@@ -3661,7 +3661,7 @@ namespace pugi
PUGI__FN void xml_writer_file::write(const void* data, size_t size)
{
size_t result = fwrite(data, 1, size, static_cast<FILE*>(file));
- (void)!result; // unfortunately we can't do proper error handling here
+ (void)!result; // unfortunately we can't do proper error handling here
}
#ifndef PUGIXML_NO_STL
@@ -3721,19 +3721,19 @@ namespace pugi
{
}
- PUGI__FN static void unspecified_bool_xml_attribute(xml_attribute***)
- {
- }
+ PUGI__FN static void unspecified_bool_xml_attribute(xml_attribute***)
+ {
+ }
PUGI__FN xml_attribute::operator xml_attribute::unspecified_bool_type() const
{
- return _attr ? unspecified_bool_xml_attribute : 0;
- }
+ return _attr ? unspecified_bool_xml_attribute : 0;
+ }
- PUGI__FN bool xml_attribute::operator!() const
- {
- return !_attr;
- }
+ PUGI__FN bool xml_attribute::operator!() const
+ {
+ return !_attr;
+ }
PUGI__FN bool xml_attribute::operator==(const xml_attribute& r) const
{
@@ -3765,15 +3765,15 @@ namespace pugi
return (_attr >= r._attr);
}
- PUGI__FN xml_attribute xml_attribute::next_attribute() const
- {
- return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
- }
+ PUGI__FN xml_attribute xml_attribute::next_attribute() const
+ {
+ return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
+ }
- PUGI__FN xml_attribute xml_attribute::previous_attribute() const
- {
- return _attr && _attr->prev_attribute_c->next_attribute ? xml_attribute(_attr->prev_attribute_c) : xml_attribute();
- }
+ PUGI__FN xml_attribute xml_attribute::previous_attribute() const
+ {
+ return _attr && _attr->prev_attribute_c->next_attribute ? xml_attribute(_attr->prev_attribute_c) : xml_attribute();
+ }
PUGI__FN const char_t* xml_attribute::as_string(const char_t* def) const
{
@@ -3782,27 +3782,27 @@ namespace pugi
PUGI__FN int xml_attribute::as_int(int def) const
{
- return impl::get_value_int(_attr ? _attr->value : 0, def);
+ return impl::get_value_int(_attr ? _attr->value : 0, def);
}
PUGI__FN unsigned int xml_attribute::as_uint(unsigned int def) const
{
- return impl::get_value_uint(_attr ? _attr->value : 0, def);
+ return impl::get_value_uint(_attr ? _attr->value : 0, def);
}
PUGI__FN double xml_attribute::as_double(double def) const
{
- return impl::get_value_double(_attr ? _attr->value : 0, def);
+ return impl::get_value_double(_attr ? _attr->value : 0, def);
}
PUGI__FN float xml_attribute::as_float(float def) const
{
- return impl::get_value_float(_attr ? _attr->value : 0, def);
+ return impl::get_value_float(_attr ? _attr->value : 0, def);
}
PUGI__FN bool xml_attribute::as_bool(bool def) const
{
- return impl::get_value_bool(_attr ? _attr->value : 0, def);
+ return impl::get_value_bool(_attr ? _attr->value : 0, def);
}
PUGI__FN bool xml_attribute::empty() const
@@ -3820,14 +3820,14 @@ namespace pugi
return (_attr && _attr->value) ? _attr->value : PUGIXML_TEXT("");
}
- PUGI__FN size_t xml_attribute::hash_value() const
- {
- return static_cast<size_t>(reinterpret_cast<uintptr_t>(_attr) / sizeof(xml_attribute_struct));
- }
+ PUGI__FN size_t xml_attribute::hash_value() const
+ {
+ return static_cast<size_t>(reinterpret_cast<uintptr_t>(_attr) / sizeof(xml_attribute_struct));
+ }
PUGI__FN xml_attribute_struct* xml_attribute::internal_object() const
{
- return _attr;
+ return _attr;
}
PUGI__FN xml_attribute& xml_attribute::operator=(const char_t* rhs)
@@ -3878,28 +3878,28 @@ namespace pugi
{
if (!_attr) return false;
- return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+ return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
}
PUGI__FN bool xml_attribute::set_value(unsigned int rhs)
{
if (!_attr) return false;
- return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+ return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
}
PUGI__FN bool xml_attribute::set_value(double rhs)
{
if (!_attr) return false;
- return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+ return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
}
PUGI__FN bool xml_attribute::set_value(bool rhs)
{
if (!_attr) return false;
- return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+ return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
}
#ifdef __BORLANDC__
@@ -3922,19 +3922,19 @@ namespace pugi
{
}
- PUGI__FN static void unspecified_bool_xml_node(xml_node***)
- {
- }
+ PUGI__FN static void unspecified_bool_xml_node(xml_node***)
+ {
+ }
PUGI__FN xml_node::operator xml_node::unspecified_bool_type() const
{
- return _root ? unspecified_bool_xml_node : 0;
- }
+ return _root ? unspecified_bool_xml_node : 0;
+ }
- PUGI__FN bool xml_node::operator!() const
- {
- return !_root;
- }
+ PUGI__FN bool xml_node::operator!() const
+ {
+ return !_root;
+ }
PUGI__FN xml_node::iterator xml_node::begin() const
{
@@ -3955,21 +3955,21 @@ namespace pugi
{
return attribute_iterator(0, _root);
}
-
- PUGI__FN xml_object_range<xml_node_iterator> xml_node::children() const
- {
- return xml_object_range<xml_node_iterator>(begin(), end());
- }
+
+ PUGI__FN xml_object_range<xml_node_iterator> xml_node::children() const
+ {
+ return xml_object_range<xml_node_iterator>(begin(), end());
+ }
- PUGI__FN xml_object_range<xml_named_node_iterator> xml_node::children(const char_t* name_) const
- {
- return xml_object_range<xml_named_node_iterator>(xml_named_node_iterator(child(name_), name_), xml_named_node_iterator());
- }
+ PUGI__FN xml_object_range<xml_named_node_iterator> xml_node::children(const char_t* name_) const
+ {
+ return xml_object_range<xml_named_node_iterator>(xml_named_node_iterator(child(name_), name_), xml_named_node_iterator());
+ }
- PUGI__FN xml_object_range<xml_attribute_iterator> xml_node::attributes() const
- {
- return xml_object_range<xml_attribute_iterator>(attributes_begin(), attributes_end());
- }
+ PUGI__FN xml_object_range<xml_attribute_iterator> xml_node::attributes() const
+ {
+ return xml_object_range<xml_attribute_iterator>(attributes_begin(), attributes_end());
+ }
PUGI__FN bool xml_node::operator==(const xml_node& r) const
{
@@ -4092,10 +4092,10 @@ namespace pugi
return xml_node(static_cast<impl::xml_document_struct*>(page->allocator));
}
- PUGI__FN xml_text xml_node::text() const
- {
- return xml_text(_root);
- }
+ PUGI__FN xml_text xml_node::text() const
+ {
+ return xml_text(_root);
+ }
PUGI__FN const char_t* xml_node::child_value() const
{
@@ -4155,7 +4155,7 @@ namespace pugi
case node_cdata:
case node_pcdata:
case node_comment:
- case node_doctype:
+ case node_doctype:
return impl::strcpy_insitu(_root->value, _root->header, impl::xml_memory_page_value_allocated_mask, rhs);
default:
@@ -4182,18 +4182,18 @@ namespace pugi
a.set_name(name_);
- xml_attribute_struct* head = _root->first_attribute;
+ xml_attribute_struct* head = _root->first_attribute;
if (head)
- {
- a._attr->prev_attribute_c = head->prev_attribute_c;
- head->prev_attribute_c = a._attr;
- }
- else
- a._attr->prev_attribute_c = a._attr;
+ {
+ a._attr->prev_attribute_c = head->prev_attribute_c;
+ head->prev_attribute_c = a._attr;
+ }
+ else
+ a._attr->prev_attribute_c = a._attr;
a._attr->next_attribute = head;
- _root->first_attribute = a._attr;
+ _root->first_attribute = a._attr;
return a;
}
@@ -4312,20 +4312,20 @@ namespace pugi
xml_node n(impl::allocate_node(impl::get_allocator(_root), type_));
if (!n) return xml_node();
- n._root->parent = _root;
+ n._root->parent = _root;
- xml_node_struct* head = _root->first_child;
+ xml_node_struct* head = _root->first_child;
if (head)
- {
- n._root->prev_sibling_c = head->prev_sibling_c;
- head->prev_sibling_c = n._root;
- }
- else
- n._root->prev_sibling_c = n._root;
+ {
+ n._root->prev_sibling_c = head->prev_sibling_c;
+ head->prev_sibling_c = n._root;
+ }
+ else
+ n._root->prev_sibling_c = n._root;
n._root->next_sibling = head;
- _root->first_child = n._root;
+ _root->first_child = n._root;
if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
@@ -4380,41 +4380,41 @@ namespace pugi
return n;
}
- PUGI__FN xml_node xml_node::append_child(const char_t* name_)
- {
- xml_node result = append_child(node_element);
+ PUGI__FN xml_node xml_node::append_child(const char_t* name_)
+ {
+ xml_node result = append_child(node_element);
- result.set_name(name_);
+ result.set_name(name_);
- return result;
- }
+ return result;
+ }
- PUGI__FN xml_node xml_node::prepend_child(const char_t* name_)
- {
- xml_node result = prepend_child(node_element);
+ PUGI__FN xml_node xml_node::prepend_child(const char_t* name_)
+ {
+ xml_node result = prepend_child(node_element);
- result.set_name(name_);
+ result.set_name(name_);
- return result;
- }
+ return result;
+ }
- PUGI__FN xml_node xml_node::insert_child_after(const char_t* name_, const xml_node& node)
- {
- xml_node result = insert_child_after(node_element, node);
+ PUGI__FN xml_node xml_node::insert_child_after(const char_t* name_, const xml_node& node)
+ {
+ xml_node result = insert_child_after(node_element, node);
- result.set_name(name_);
+ result.set_name(name_);
- return result;
- }
+ return result;
+ }
- PUGI__FN xml_node xml_node::insert_child_before(const char_t* name_, const xml_node& node)
- {
- xml_node result = insert_child_before(node_element, node);
+ PUGI__FN xml_node xml_node::insert_child_before(const char_t* name_, const xml_node& node)
+ {
+ xml_node result = insert_child_before(node_element, node);
- result.set_name(name_);
+ result.set_name(name_);
- return result;
- }
+ return result;
+ }
PUGI__FN xml_node xml_node::append_copy(const xml_node& proto)
{
@@ -4493,8 +4493,8 @@ namespace pugi
if (n._root->prev_sibling_c->next_sibling) n._root->prev_sibling_c->next_sibling = n._root->next_sibling;
else _root->first_child = n._root->next_sibling;
-
- impl::destroy_node(n._root, impl::get_allocator(_root));
+
+ impl::destroy_node(n._root, impl::get_allocator(_root));
return true;
}
@@ -4642,14 +4642,14 @@ namespace pugi
return walker.end(arg_end);
}
- PUGI__FN size_t xml_node::hash_value() const
- {
- return static_cast<size_t>(reinterpret_cast<uintptr_t>(_root) / sizeof(xml_node_struct));
- }
+ PUGI__FN size_t xml_node::hash_value() const
+ {
+ return static_cast<size_t>(reinterpret_cast<uintptr_t>(_root) / sizeof(xml_node_struct));
+ }
PUGI__FN xml_node_struct* xml_node::internal_object() const
{
- return _root;
+ return _root;
}
PUGI__FN void xml_node::print(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
@@ -4720,170 +4720,170 @@ namespace pugi
}
#endif
- PUGI__FN xml_text::xml_text(xml_node_struct* root): _root(root)
- {
- }
+ PUGI__FN xml_text::xml_text(xml_node_struct* root): _root(root)
+ {
+ }
- PUGI__FN xml_node_struct* xml_text::_data() const
- {
- if (!_root || impl::is_text_node(_root)) return _root;
+ PUGI__FN xml_node_struct* xml_text::_data() const
+ {
+ if (!_root || impl::is_text_node(_root)) return _root;
- for (xml_node_struct* node = _root->first_child; node; node = node->next_sibling)
- if (impl::is_text_node(node))
- return node;
+ for (xml_node_struct* node = _root->first_child; node; node = node->next_sibling)
+ if (impl::is_text_node(node))
+ return node;
- return 0;
- }
+ return 0;
+ }
- PUGI__FN xml_node_struct* xml_text::_data_new()
- {
- xml_node_struct* d = _data();
- if (d) return d;
+ PUGI__FN xml_node_struct* xml_text::_data_new()
+ {
+ xml_node_struct* d = _data();
+ if (d) return d;
- return xml_node(_root).append_child(node_pcdata).internal_object();
- }
+ return xml_node(_root).append_child(node_pcdata).internal_object();
+ }
- PUGI__FN xml_text::xml_text(): _root(0)
- {
- }
+ PUGI__FN xml_text::xml_text(): _root(0)
+ {
+ }
- PUGI__FN static void unspecified_bool_xml_text(xml_text***)
- {
- }
+ PUGI__FN static void unspecified_bool_xml_text(xml_text***)
+ {
+ }
- PUGI__FN xml_text::operator xml_text::unspecified_bool_type() const
- {
- return _data() ? unspecified_bool_xml_text : 0;
- }
+ PUGI__FN xml_text::operator xml_text::unspecified_bool_type() const
+ {
+ return _data() ? unspecified_bool_xml_text : 0;
+ }
- PUGI__FN bool xml_text::operator!() const
- {
- return !_data();
- }
+ PUGI__FN bool xml_text::operator!() const
+ {
+ return !_data();
+ }
- PUGI__FN bool xml_text::empty() const
- {
- return _data() == 0;
- }
+ PUGI__FN bool xml_text::empty() const
+ {
+ return _data() == 0;
+ }
- PUGI__FN const char_t* xml_text::get() const
- {
- xml_node_struct* d = _data();
+ PUGI__FN const char_t* xml_text::get() const
+ {
+ xml_node_struct* d = _data();
- return (d && d->value) ? d->value : PUGIXML_TEXT("");
- }
+ return (d && d->value) ? d->value : PUGIXML_TEXT("");
+ }
- PUGI__FN const char_t* xml_text::as_string(const char_t* def) const
- {
- xml_node_struct* d = _data();
+ PUGI__FN const char_t* xml_text::as_string(const char_t* def) const
+ {
+ xml_node_struct* d = _data();
- return (d && d->value) ? d->value : def;
- }
+ return (d && d->value) ? d->value : def;
+ }
- PUGI__FN int xml_text::as_int(int def) const
- {
- xml_node_struct* d = _data();
+ PUGI__FN int xml_text::as_int(int def) const
+ {
+ xml_node_struct* d = _data();
- return impl::get_value_int(d ? d->value : 0, def);
- }
+ return impl::get_value_int(d ? d->value : 0, def);
+ }
- PUGI__FN unsigned int xml_text::as_uint(unsigned int def) const
- {
- xml_node_struct* d = _data();
+ PUGI__FN unsigned int xml_text::as_uint(unsigned int def) const
+ {
+ xml_node_struct* d = _data();
- return impl::get_value_uint(d ? d->value : 0, def);
- }
+ return impl::get_value_uint(d ? d->value : 0, def);
+ }
- PUGI__FN double xml_text::as_double(double def) const
- {
- xml_node_struct* d = _data();
+ PUGI__FN double xml_text::as_double(double def) const
+ {
+ xml_node_struct* d = _data();
- return impl::get_value_double(d ? d->value : 0, def);
- }
+ return impl::get_value_double(d ? d->value : 0, def);
+ }
- PUGI__FN float xml_text::as_float(float def) const
- {
- xml_node_struct* d = _data();
+ PUGI__FN float xml_text::as_float(float def) const
+ {
+ xml_node_struct* d = _data();
- return impl::get_value_float(d ? d->value : 0, def);
- }
+ return impl::get_value_float(d ? d->value : 0, def);
+ }
- PUGI__FN bool xml_text::as_bool(bool def) const
- {
- xml_node_struct* d = _data();
+ PUGI__FN bool xml_text::as_bool(bool def) const
+ {
+ xml_node_struct* d = _data();
- return impl::get_value_bool(d ? d->value : 0, def);
- }
+ return impl::get_value_bool(d ? d->value : 0, def);
+ }
- PUGI__FN bool xml_text::set(const char_t* rhs)
- {
- xml_node_struct* dn = _data_new();
+ PUGI__FN bool xml_text::set(const char_t* rhs)
+ {
+ xml_node_struct* dn = _data_new();
- return dn ? impl::strcpy_insitu(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
- }
+ return dn ? impl::strcpy_insitu(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+ }
- PUGI__FN bool xml_text::set(int rhs)
- {
- xml_node_struct* dn = _data_new();
+ PUGI__FN bool xml_text::set(int rhs)
+ {
+ xml_node_struct* dn = _data_new();
- return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
- }
+ return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+ }
- PUGI__FN bool xml_text::set(unsigned int rhs)
- {
- xml_node_struct* dn = _data_new();
+ PUGI__FN bool xml_text::set(unsigned int rhs)
+ {
+ xml_node_struct* dn = _data_new();
- return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
- }
+ return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+ }
- PUGI__FN bool xml_text::set(double rhs)
- {
- xml_node_struct* dn = _data_new();
+ PUGI__FN bool xml_text::set(double rhs)
+ {
+ xml_node_struct* dn = _data_new();
- return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
- }
+ return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+ }
- PUGI__FN bool xml_text::set(bool rhs)
- {
- xml_node_struct* dn = _data_new();
+ PUGI__FN bool xml_text::set(bool rhs)
+ {
+ xml_node_struct* dn = _data_new();
- return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
- }
+ return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+ }
- PUGI__FN xml_text& xml_text::operator=(const char_t* rhs)
- {
- set(rhs);
- return *this;
- }
+ PUGI__FN xml_text& xml_text::operator=(const char_t* rhs)
+ {
+ set(rhs);
+ return *this;
+ }
- PUGI__FN xml_text& xml_text::operator=(int rhs)
- {
- set(rhs);
- return *this;
- }
+ PUGI__FN xml_text& xml_text::operator=(int rhs)
+ {
+ set(rhs);
+ return *this;
+ }
- PUGI__FN xml_text& xml_text::operator=(unsigned int rhs)
- {
- set(rhs);
- return *this;
- }
+ PUGI__FN xml_text& xml_text::operator=(unsigned int rhs)
+ {
+ set(rhs);
+ return *this;
+ }
- PUGI__FN xml_text& xml_text::operator=(double rhs)
- {
- set(rhs);
- return *this;
- }
+ PUGI__FN xml_text& xml_text::operator=(double rhs)
+ {
+ set(rhs);
+ return *this;
+ }
- PUGI__FN xml_text& xml_text::operator=(bool rhs)
- {
- set(rhs);
- return *this;
- }
+ PUGI__FN xml_text& xml_text::operator=(bool rhs)
+ {
+ set(rhs);
+ return *this;
+ }
- PUGI__FN xml_node xml_text::data() const
- {
- return xml_node(_data());
- }
+ PUGI__FN xml_node xml_text::data() const
+ {
+ return xml_node(_data());
+ }
#ifdef __BORLANDC__
PUGI__FN bool operator&&(const xml_text& lhs, bool rhs)
@@ -5019,55 +5019,55 @@ namespace pugi
return temp;
}
- PUGI__FN xml_named_node_iterator::xml_named_node_iterator(): _name(0)
- {
- }
-
- PUGI__FN xml_named_node_iterator::xml_named_node_iterator(const xml_node& node, const char_t* name): _node(node), _name(name)
- {
- }
-
- PUGI__FN bool xml_named_node_iterator::operator==(const xml_named_node_iterator& rhs) const
- {
- return _node == rhs._node;
- }
-
- PUGI__FN bool xml_named_node_iterator::operator!=(const xml_named_node_iterator& rhs) const
- {
- return _node != rhs._node;
- }
-
- PUGI__FN xml_node& xml_named_node_iterator::operator*() const
- {
- return _node;
- }
-
- PUGI__FN xml_node* xml_named_node_iterator::operator->() const
- {
- return &_node;
- }
-
- PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator++()
- {
- _node = _node.next_sibling(_name);
- return *this;
- }
-
- PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator++(int)
- {
- xml_named_node_iterator temp = *this;
- ++*this;
- return temp;
- }
-
- PUGI__FN xml_parse_result::xml_parse_result(): status(status_internal_error), offset(0), encoding(encoding_auto)
- {
- }
-
- PUGI__FN xml_parse_result::operator bool() const
- {
- return status == status_ok;
- }
+ PUGI__FN xml_named_node_iterator::xml_named_node_iterator(): _name(0)
+ {
+ }
+
+ PUGI__FN xml_named_node_iterator::xml_named_node_iterator(const xml_node& node, const char_t* name): _node(node), _name(name)
+ {
+ }
+
+ PUGI__FN bool xml_named_node_iterator::operator==(const xml_named_node_iterator& rhs) const
+ {
+ return _node == rhs._node;
+ }
+
+ PUGI__FN bool xml_named_node_iterator::operator!=(const xml_named_node_iterator& rhs) const
+ {
+ return _node != rhs._node;
+ }
+
+ PUGI__FN xml_node& xml_named_node_iterator::operator*() const
+ {
+ return _node;
+ }
+
+ PUGI__FN xml_node* xml_named_node_iterator::operator->() const
+ {
+ return &_node;
+ }
+
+ PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator++()
+ {
+ _node = _node.next_sibling(_name);
+ return *this;
+ }
+
+ PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator++(int)
+ {
+ xml_named_node_iterator temp = *this;
+ ++*this;
+ return temp;
+ }
+
+ PUGI__FN xml_parse_result::xml_parse_result(): status(status_internal_error), offset(0), encoding(encoding_auto)
+ {
+ }
+
+ PUGI__FN xml_parse_result::operator bool() const
+ {
+ return status == status_ok;
+ }
PUGI__FN const char* xml_parse_result::description() const
{
@@ -5112,13 +5112,13 @@ namespace pugi
create();
}
- PUGI__FN void xml_document::reset(const xml_document& proto)
- {
- reset();
+ PUGI__FN void xml_document::reset(const xml_document& proto)
+ {
+ reset();
- for (xml_node cur = proto.first_child(); cur; cur = cur.next_sibling())
- append_copy(cur);
- }
+ for (xml_node cur = proto.first_child(); cur; cur = cur.next_sibling())
+ append_copy(cur);
+ }
PUGI__FN void xml_document::create()
{
@@ -5272,20 +5272,20 @@ namespace pugi
impl::xml_buffered_writer buffered_writer(writer, encoding);
if ((flags & format_write_bom) && encoding != encoding_latin1)
- {
- // BOM always represents the codepoint U+FEFF, so just write it in native encoding
- #ifdef PUGIXML_WCHAR_MODE
- unsigned int bom = 0xfeff;
- buffered_writer.write(static_cast<wchar_t>(bom));
- #else
- buffered_writer.write('\xef', '\xbb', '\xbf');
- #endif
- }
+ {
+ // BOM always represents the codepoint U+FEFF, so just write it in native encoding
+ #ifdef PUGIXML_WCHAR_MODE
+ unsigned int bom = 0xfeff;
+ buffered_writer.write(static_cast<wchar_t>(bom));
+ #else
+ buffered_writer.write('\xef', '\xbb', '\xbf');
+ #endif
+ }
if (!(flags & format_no_declaration) && !impl::has_declaration(*this))
{
buffered_writer.write(PUGIXML_TEXT("<?xml version=\"1.0\""));
- if (encoding == encoding_latin1) buffered_writer.write(PUGIXML_TEXT(" encoding=\"ISO-8859-1\""));
+ if (encoding == encoding_latin1) buffered_writer.write(PUGIXML_TEXT(" encoding=\"ISO-8859-1\""));
buffered_writer.write('?', '>');
if (!(flags & format_raw)) buffered_writer.write('\n');
}
@@ -5312,65 +5312,65 @@ namespace pugi
PUGI__FN bool xml_document::save_file(const char* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
{
FILE* file = fopen(path_, (flags & format_save_file_text) ? "w" : "wb");
- return impl::save_file_impl(*this, file, indent, flags, encoding);
+ return impl::save_file_impl(*this, file, indent, flags, encoding);
}
PUGI__FN bool xml_document::save_file(const wchar_t* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
{
FILE* file = impl::open_file_wide(path_, (flags & format_save_file_text) ? L"w" : L"wb");
- return impl::save_file_impl(*this, file, indent, flags, encoding);
+ return impl::save_file_impl(*this, file, indent, flags, encoding);
}
- PUGI__FN xml_node xml_document::document_element() const
- {
+ PUGI__FN xml_node xml_document::document_element() const
+ {
for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
if ((i->header & impl::xml_memory_page_type_mask) + 1 == node_element)
- return xml_node(i);
+ return xml_node(i);
- return xml_node();
- }
+ return xml_node();
+ }
#ifndef PUGIXML_NO_STL
PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const wchar_t* str)
{
assert(str);
- return impl::as_utf8_impl(str, wcslen(str));
+ return impl::as_utf8_impl(str, wcslen(str));
}
PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const std::basic_string<wchar_t>& str)
{
- return impl::as_utf8_impl(str.c_str(), str.size());
+ return impl::as_utf8_impl(str.c_str(), str.size());
}
PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const char* str)
{
assert(str);
- return impl::as_wide_impl(str, strlen(str));
+ return impl::as_wide_impl(str, strlen(str));
}
PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const std::string& str)
{
- return impl::as_wide_impl(str.c_str(), str.size());
+ return impl::as_wide_impl(str.c_str(), str.size());
}
#endif
- PUGI__FN void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate)
- {
- impl::xml_memory::allocate = allocate;
- impl::xml_memory::deallocate = deallocate;
- }
-
- PUGI__FN allocation_function PUGIXML_FUNCTION get_memory_allocation_function()
- {
- return impl::xml_memory::allocate;
- }
-
- PUGI__FN deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function()
- {
- return impl::xml_memory::deallocate;
- }
+ PUGI__FN void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate)
+ {
+ impl::xml_memory::allocate = allocate;
+ impl::xml_memory::deallocate = deallocate;
+ }
+
+ PUGI__FN allocation_function PUGIXML_FUNCTION get_memory_allocation_function()
+ {
+ return impl::xml_memory::allocate;
+ }
+
+ PUGI__FN deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function()
+ {
+ return impl::xml_memory::deallocate;
+ }
}
#if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) || defined(__ICC))
@@ -5651,12 +5651,12 @@ PUGI__NS_BEGIN
xpath_memory_block* next;
char data[
- #ifdef PUGIXML_MEMORY_XPATH_PAGE_SIZE
- PUGIXML_MEMORY_XPATH_PAGE_SIZE
- #else
- 4096
- #endif
- ];
+ #ifdef PUGIXML_MEMORY_XPATH_PAGE_SIZE
+ PUGIXML_MEMORY_XPATH_PAGE_SIZE
+ #else
+ 4096
+ #endif
+ ];
};
class xpath_allocator
@@ -6077,15 +6077,15 @@ PUGI__NS_BEGIN
PUGI__FN unsigned int node_height(xml_node n)
{
- unsigned int result = 0;
-
- while (n)
- {
- ++result;
- n = n.parent();
- }
-
- return result;
+ unsigned int result = 0;
+
+ while (n)
+ {
+ ++result;
+ n = n.parent();
+ }
+
+ return result;
}
PUGI__FN bool node_is_before(xml_node ln, unsigned int lh, xml_node rn, unsigned int rh)
@@ -6093,58 +6093,58 @@ PUGI__NS_BEGIN
// normalize heights
for (unsigned int i = rh; i < lh; i++) ln = ln.parent();
for (unsigned int j = lh; j < rh; j++) rn = rn.parent();
-
+
// one node is the ancestor of the other
- if (ln == rn) return lh < rh;
-
+ if (ln == rn) return lh < rh;
+
// find common ancestor
- while (ln.parent() != rn.parent())
- {
- ln = ln.parent();
- rn = rn.parent();
- }
+ while (ln.parent() != rn.parent())
+ {
+ ln = ln.parent();
+ rn = rn.parent();
+ }
// there is no common ancestor (the shared parent is null), nodes are from different documents
if (!ln.parent()) return ln < rn;
// determine sibling order
- for (; ln; ln = ln.next_sibling())
- if (ln == rn)
- return true;
-
- return false;
- }
-
- PUGI__FN bool node_is_ancestor(xml_node parent, xml_node node)
- {
- while (node && node != parent) node = node.parent();
-
- return parent && node == parent;
- }
-
- PUGI__FN const void* document_order(const xpath_node& xnode)
- {
- xml_node_struct* node = xnode.node().internal_object();
-
- if (node)
- {
- if (node->name && (node->header & xml_memory_page_name_allocated_mask) == 0) return node->name;
- if (node->value && (node->header & xml_memory_page_value_allocated_mask) == 0) return node->value;
- return 0;
- }
-
- xml_attribute_struct* attr = xnode.attribute().internal_object();
-
- if (attr)
- {
- if ((attr->header & xml_memory_page_name_allocated_mask) == 0) return attr->name;
- if ((attr->header & xml_memory_page_value_allocated_mask) == 0) return attr->value;
- return 0;
- }
+ for (; ln; ln = ln.next_sibling())
+ if (ln == rn)
+ return true;
+
+ return false;
+ }
+
+ PUGI__FN bool node_is_ancestor(xml_node parent, xml_node node)
+ {
+ while (node && node != parent) node = node.parent();
+
+ return parent && node == parent;
+ }
+
+ PUGI__FN const void* document_order(const xpath_node& xnode)
+ {
+ xml_node_struct* node = xnode.node().internal_object();
+
+ if (node)
+ {
+ if (node->name && (node->header & xml_memory_page_name_allocated_mask) == 0) return node->name;
+ if (node->value && (node->header & xml_memory_page_value_allocated_mask) == 0) return node->value;
+ return 0;
+ }
+
+ xml_attribute_struct* attr = xnode.attribute().internal_object();
+
+ if (attr)
+ {
+ if ((attr->header & xml_memory_page_name_allocated_mask) == 0) return attr->name;
+ if ((attr->header & xml_memory_page_value_allocated_mask) == 0) return attr->value;
+ return 0;
+ }
return 0;
- }
-
+ }
+
struct document_order_comparator
{
bool operator()(const xpath_node& lhs, const xpath_node& rhs) const
@@ -6155,7 +6155,7 @@ PUGI__NS_BEGIN
if (lo && ro) return lo < ro;
- // slow comparison
+ // slow comparison
xml_node ln = lhs.node(), rn = rhs.node();
// compare attributes
@@ -6165,11 +6165,11 @@ PUGI__NS_BEGIN
if (lhs.parent() == rhs.parent())
{
// determine sibling order
- for (xml_attribute a = lhs.attribute(); a; a = a.next_attribute())
- if (a == rhs.attribute())
- return true;
-
- return false;
+ for (xml_attribute a = lhs.attribute(); a; a = a.next_attribute())
+ if (a == rhs.attribute())
+ return true;
+
+ return false;
}
// compare attribute parents
@@ -6248,7 +6248,7 @@ PUGI__NS_BEGIN
return PUGIXML_TEXT("NaN");
case FP_INFINITE:
- return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
+ return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
case FP_ZERO:
return PUGIXML_TEXT("0");
@@ -7278,7 +7278,7 @@ PUGI__NS_BEGIN
ast_op_or, // left or right
ast_op_and, // left and right
ast_op_equal, // left = right
- ast_op_not_equal, // left != right
+ ast_op_not_equal, // left != right
ast_op_less, // left < right
ast_op_greater, // left > right
ast_op_less_or_equal, // left <= right
@@ -8562,7 +8562,7 @@ PUGI__NS_BEGIN
xpath_node_set_raw rs = _right->eval_node_set(c, stack);
// we can optimize merging two sorted sets, but this is a very rare operation, so don't bother
- rs.set_type(xpath_node_set::type_unsorted);
+ rs.set_type(xpath_node_set::type_unsorted);
rs.append(ls.begin(), ls.end(), stack.result);
rs.remove_duplicates();
@@ -8630,9 +8630,9 @@ PUGI__NS_BEGIN
case axis_self:
return step_do(c, stack, axis_to_type<axis_self>());
- default:
- assert(!"Unknown axis");
- return xpath_node_set_raw();
+ default:
+ assert(!"Unknown axis");
+ return xpath_node_set_raw();
}
}
@@ -8714,8 +8714,8 @@ PUGI__NS_BEGIN
struct xpath_parser
{
- xpath_allocator* _alloc;
- xpath_lexer _lexer;
+ xpath_allocator* _alloc;
+ xpath_lexer _lexer;
const char_t* _query;
xpath_variable_set* _variables;
@@ -8739,13 +8739,13 @@ PUGI__NS_BEGIN
}
void throw_error_oom()
- {
- #ifdef PUGIXML_NO_EXCEPTIONS
- throw_error("Out of memory");
- #else
- throw std::bad_alloc();
- #endif
- }
+ {
+ #ifdef PUGIXML_NO_EXCEPTIONS
+ throw_error("Out of memory");
+ #else
+ throw std::bad_alloc();
+ #endif
+ }
void* alloc_node()
{
@@ -8886,8 +8886,8 @@ PUGI__NS_BEGIN
break;
- default:
- break;
+ default:
+ break;
}
throw_error("Unrecognized function or wrong parameter count");
@@ -8955,8 +8955,8 @@ PUGI__NS_BEGIN
break;
- default:
- break;
+ default:
+ break;
}
specified = false;
@@ -8990,21 +8990,21 @@ PUGI__NS_BEGIN
return nodetest_type_text;
break;
-
- default:
- break;
+
+ default:
+ break;
}
- return nodetest_none;
+ return nodetest_none;
}
- // PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
- xpath_ast_node* parse_primary_expression()
- {
- switch (_lexer.current())
- {
- case lex_var_ref:
- {
+ // PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+ xpath_ast_node* parse_primary_expression()
+ {
+ switch (_lexer.current())
+ {
+ case lex_var_ref:
+ {
xpath_lexer_string name = _lexer.contents();
if (!_variables)
@@ -9017,7 +9017,7 @@ PUGI__NS_BEGIN
_lexer.next();
- return new (alloc_node()) xpath_ast_node(ast_variable, var->type(), var);
+ return new (alloc_node()) xpath_ast_node(ast_variable, var->type(), var);
}
case lex_open_brace:
@@ -9094,23 +9094,23 @@ PUGI__NS_BEGIN
return parse_function(function, argc, args);
}
- default:
- throw_error("Unrecognizable primary expression");
+ default:
+ throw_error("Unrecognizable primary expression");
- return 0;
- }
- }
-
- // FilterExpr ::= PrimaryExpr | FilterExpr Predicate
- // Predicate ::= '[' PredicateExpr ']'
- // PredicateExpr ::= Expr
- xpath_ast_node* parse_filter_expression()
- {
- xpath_ast_node* n = parse_primary_expression();
+ return 0;
+ }
+ }
+
+ // FilterExpr ::= PrimaryExpr | FilterExpr Predicate
+ // Predicate ::= '[' PredicateExpr ']'
+ // PredicateExpr ::= Expr
+ xpath_ast_node* parse_filter_expression()
+ {
+ xpath_ast_node* n = parse_primary_expression();
- while (_lexer.current() == lex_open_square_brace)
- {
- _lexer.next();
+ while (_lexer.current() == lex_open_square_brace)
+ {
+ _lexer.next();
xpath_ast_node* expr = parse_expression();
@@ -9118,24 +9118,24 @@ PUGI__NS_BEGIN
bool posinv = expr->rettype() != xpath_type_number && expr->is_posinv();
- n = new (alloc_node()) xpath_ast_node(posinv ? ast_filter_posinv : ast_filter, xpath_type_node_set, n, expr);
-
- if (_lexer.current() != lex_close_square_brace)
- throw_error("Unmatched square brace");
-
- _lexer.next();
- }
-
- return n;
- }
-
- // Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
- // AxisSpecifier ::= AxisName '::' | '@'?
- // NodeTest ::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
- // NameTest ::= '*' | NCName ':' '*' | QName
- // AbbreviatedStep ::= '.' | '..'
- xpath_ast_node* parse_step(xpath_ast_node* set)
- {
+ n = new (alloc_node()) xpath_ast_node(posinv ? ast_filter_posinv : ast_filter, xpath_type_node_set, n, expr);
+
+ if (_lexer.current() != lex_close_square_brace)
+ throw_error("Unmatched square brace");
+
+ _lexer.next();
+ }
+
+ return n;
+ }
+
+ // Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
+ // AxisSpecifier ::= AxisName '::' | '@'?
+ // NodeTest ::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
+ // NameTest ::= '*' | NCName ':' '*' | QName
+ // AbbreviatedStep ::= '.' | '..'
+ xpath_ast_node* parse_step(xpath_ast_node* set)
+ {
if (set && set->rettype() != xpath_type_node_set)
throw_error("Step has to be applied to node set");
@@ -9161,7 +9161,7 @@ PUGI__NS_BEGIN
return new (alloc_node()) xpath_ast_node(ast_step, set, axis_parent, nodetest_type_node, 0);
}
-
+
nodetest_t nt_type = nodetest_none;
xpath_lexer_string nt_name;
@@ -9265,7 +9265,7 @@ PUGI__NS_BEGIN
xpath_ast_node* pred = new (alloc_node()) xpath_ast_node(ast_predicate, xpath_type_node_set, expr);
if (_lexer.current() != lex_close_square_brace)
- throw_error("Unmatched square brace");
+ throw_error("Unmatched square brace");
_lexer.next();
if (last) last->set_next(pred);
@@ -9275,11 +9275,11 @@ PUGI__NS_BEGIN
}
return n;
- }
-
- // RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
- xpath_ast_node* parse_relative_location_path(xpath_ast_node* set)
- {
+ }
+
+ // RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
+ xpath_ast_node* parse_relative_location_path(xpath_ast_node* set)
+ {
xpath_ast_node* n = parse_step(set);
while (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
@@ -9294,12 +9294,12 @@ PUGI__NS_BEGIN
}
return n;
- }
-
- // LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
- // AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
- xpath_ast_node* parse_location_path()
- {
+ }
+
+ // LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
+ // AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
+ xpath_ast_node* parse_location_path()
+ {
if (_lexer.current() == lex_slash)
{
_lexer.next();
@@ -9326,14 +9326,14 @@ PUGI__NS_BEGIN
// else clause moved outside of if because of bogus warning 'control may reach end of non-void function being inlined' in gcc 4.0.1
return parse_relative_location_path(0);
- }
-
- // PathExpr ::= LocationPath
- // | FilterExpr
- // | FilterExpr '/' RelativeLocationPath
- // | FilterExpr '//' RelativeLocationPath
- xpath_ast_node* parse_path_expression()
- {
+ }
+
+ // PathExpr ::= LocationPath
+ // | FilterExpr
+ // | FilterExpr '/' RelativeLocationPath
+ // | FilterExpr '//' RelativeLocationPath
+ xpath_ast_node* parse_path_expression()
+ {
// Clarification.
// PathExpr begins with either LocationPath or FilterExpr.
// FilterExpr begins with PrimaryExpr
@@ -9344,27 +9344,27 @@ PUGI__NS_BEGIN
if (_lexer.current() == lex_var_ref || _lexer.current() == lex_open_brace ||
_lexer.current() == lex_quoted_string || _lexer.current() == lex_number ||
_lexer.current() == lex_string)
- {
- if (_lexer.current() == lex_string)
- {
- // This is either a function call, or not - if not, we shall proceed with location path
- const char_t* state = _lexer.state();
-
+ {
+ if (_lexer.current() == lex_string)
+ {
+ // This is either a function call, or not - if not, we shall proceed with location path
+ const char_t* state = _lexer.state();
+
while (PUGI__IS_CHARTYPE(*state, ct_space)) ++state;
-
- if (*state != '(') return parse_location_path();
+
+ if (*state != '(') return parse_location_path();
// This looks like a function call; however this still can be a node-test. Check it.
if (parse_node_test_type(_lexer.contents()) != nodetest_none) return parse_location_path();
- }
-
- xpath_ast_node* n = parse_filter_expression();
+ }
+
+ xpath_ast_node* n = parse_filter_expression();
- if (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
- {
+ if (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
+ {
lexeme_t l = _lexer.current();
- _lexer.next();
-
+ _lexer.next();
+
if (l == lex_double_slash)
{
if (n->rettype() != xpath_type_node_set) throw_error("Step has to be applied to node set");
@@ -9372,171 +9372,171 @@ PUGI__NS_BEGIN
n = new (alloc_node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
}
- // select from location path
- return parse_relative_location_path(n);
- }
+ // select from location path
+ return parse_relative_location_path(n);
+ }
- return n;
- }
- else return parse_location_path();
- }
+ return n;
+ }
+ else return parse_location_path();
+ }
- // UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
- xpath_ast_node* parse_union_expression()
- {
- xpath_ast_node* n = parse_path_expression();
+ // UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
+ xpath_ast_node* parse_union_expression()
+ {
+ xpath_ast_node* n = parse_path_expression();
- while (_lexer.current() == lex_union)
- {
- _lexer.next();
+ while (_lexer.current() == lex_union)
+ {
+ _lexer.next();
xpath_ast_node* expr = parse_union_expression();
if (n->rettype() != xpath_type_node_set || expr->rettype() != xpath_type_node_set)
throw_error("Union operator has to be applied to node sets");
- n = new (alloc_node()) xpath_ast_node(ast_op_union, xpath_type_node_set, n, expr);
- }
+ n = new (alloc_node()) xpath_ast_node(ast_op_union, xpath_type_node_set, n, expr);
+ }
- return n;
- }
+ return n;
+ }
- // UnaryExpr ::= UnionExpr | '-' UnaryExpr
- xpath_ast_node* parse_unary_expression()
- {
- if (_lexer.current() == lex_minus)
- {
- _lexer.next();
+ // UnaryExpr ::= UnionExpr | '-' UnaryExpr
+ xpath_ast_node* parse_unary_expression()
+ {
+ if (_lexer.current() == lex_minus)
+ {
+ _lexer.next();
xpath_ast_node* expr = parse_unary_expression();
- return new (alloc_node()) xpath_ast_node(ast_op_negate, xpath_type_number, expr);
- }
- else return parse_union_expression();
- }
-
- // MultiplicativeExpr ::= UnaryExpr
- // | MultiplicativeExpr '*' UnaryExpr
- // | MultiplicativeExpr 'div' UnaryExpr
- // | MultiplicativeExpr 'mod' UnaryExpr
- xpath_ast_node* parse_multiplicative_expression()
- {
- xpath_ast_node* n = parse_unary_expression();
-
- while (_lexer.current() == lex_multiply || (_lexer.current() == lex_string &&
- (_lexer.contents() == PUGIXML_TEXT("mod") || _lexer.contents() == PUGIXML_TEXT("div"))))
- {
- ast_type_t op = _lexer.current() == lex_multiply ? ast_op_multiply :
- _lexer.contents().begin[0] == 'd' ? ast_op_divide : ast_op_mod;
- _lexer.next();
+ return new (alloc_node()) xpath_ast_node(ast_op_negate, xpath_type_number, expr);
+ }
+ else return parse_union_expression();
+ }
+
+ // MultiplicativeExpr ::= UnaryExpr
+ // | MultiplicativeExpr '*' UnaryExpr
+ // | MultiplicativeExpr 'div' UnaryExpr
+ // | MultiplicativeExpr 'mod' UnaryExpr
+ xpath_ast_node* parse_multiplicative_expression()
+ {
+ xpath_ast_node* n = parse_unary_expression();
+
+ while (_lexer.current() == lex_multiply || (_lexer.current() == lex_string &&
+ (_lexer.contents() == PUGIXML_TEXT("mod") || _lexer.contents() == PUGIXML_TEXT("div"))))
+ {
+ ast_type_t op = _lexer.current() == lex_multiply ? ast_op_multiply :
+ _lexer.contents().begin[0] == 'd' ? ast_op_divide : ast_op_mod;
+ _lexer.next();
xpath_ast_node* expr = parse_unary_expression();
- n = new (alloc_node()) xpath_ast_node(op, xpath_type_number, n, expr);
- }
+ n = new (alloc_node()) xpath_ast_node(op, xpath_type_number, n, expr);
+ }
- return n;
- }
+ return n;
+ }
- // AdditiveExpr ::= MultiplicativeExpr
- // | AdditiveExpr '+' MultiplicativeExpr
- // | AdditiveExpr '-' MultiplicativeExpr
- xpath_ast_node* parse_additive_expression()
- {
- xpath_ast_node* n = parse_multiplicative_expression();
+ // AdditiveExpr ::= MultiplicativeExpr
+ // | AdditiveExpr '+' MultiplicativeExpr
+ // | AdditiveExpr '-' MultiplicativeExpr
+ xpath_ast_node* parse_additive_expression()
+ {
+ xpath_ast_node* n = parse_multiplicative_expression();
- while (_lexer.current() == lex_plus || _lexer.current() == lex_minus)
- {
- lexeme_t l = _lexer.current();
+ while (_lexer.current() == lex_plus || _lexer.current() == lex_minus)
+ {
+ lexeme_t l = _lexer.current();
- _lexer.next();
+ _lexer.next();
xpath_ast_node* expr = parse_multiplicative_expression();
- n = new (alloc_node()) xpath_ast_node(l == lex_plus ? ast_op_add : ast_op_subtract, xpath_type_number, n, expr);
- }
+ n = new (alloc_node()) xpath_ast_node(l == lex_plus ? ast_op_add : ast_op_subtract, xpath_type_number, n, expr);
+ }
- return n;
- }
+ return n;
+ }
- // RelationalExpr ::= AdditiveExpr
- // | RelationalExpr '<' AdditiveExpr
- // | RelationalExpr '>' AdditiveExpr
- // | RelationalExpr '<=' AdditiveExpr
- // | RelationalExpr '>=' AdditiveExpr
- xpath_ast_node* parse_relational_expression()
- {
- xpath_ast_node* n = parse_additive_expression();
+ // RelationalExpr ::= AdditiveExpr
+ // | RelationalExpr '<' AdditiveExpr
+ // | RelationalExpr '>' AdditiveExpr
+ // | RelationalExpr '<=' AdditiveExpr
+ // | RelationalExpr '>=' AdditiveExpr
+ xpath_ast_node* parse_relational_expression()
+ {
+ xpath_ast_node* n = parse_additive_expression();
- while (_lexer.current() == lex_less || _lexer.current() == lex_less_or_equal ||
- _lexer.current() == lex_greater || _lexer.current() == lex_greater_or_equal)
- {
- lexeme_t l = _lexer.current();
- _lexer.next();
+ while (_lexer.current() == lex_less || _lexer.current() == lex_less_or_equal ||
+ _lexer.current() == lex_greater || _lexer.current() == lex_greater_or_equal)
+ {
+ lexeme_t l = _lexer.current();
+ _lexer.next();
xpath_ast_node* expr = parse_additive_expression();
- n = new (alloc_node()) xpath_ast_node(l == lex_less ? ast_op_less : l == lex_greater ? ast_op_greater :
- l == lex_less_or_equal ? ast_op_less_or_equal : ast_op_greater_or_equal, xpath_type_boolean, n, expr);
- }
+ n = new (alloc_node()) xpath_ast_node(l == lex_less ? ast_op_less : l == lex_greater ? ast_op_greater :
+ l == lex_less_or_equal ? ast_op_less_or_equal : ast_op_greater_or_equal, xpath_type_boolean, n, expr);
+ }
- return n;
- }
-
- // EqualityExpr ::= RelationalExpr
- // | EqualityExpr '=' RelationalExpr
- // | EqualityExpr '!=' RelationalExpr
- xpath_ast_node* parse_equality_expression()
- {
- xpath_ast_node* n = parse_relational_expression();
+ return n;
+ }
+
+ // EqualityExpr ::= RelationalExpr
+ // | EqualityExpr '=' RelationalExpr
+ // | EqualityExpr '!=' RelationalExpr
+ xpath_ast_node* parse_equality_expression()
+ {
+ xpath_ast_node* n = parse_relational_expression();
- while (_lexer.current() == lex_equal || _lexer.current() == lex_not_equal)
- {
- lexeme_t l = _lexer.current();
+ while (_lexer.current() == lex_equal || _lexer.current() == lex_not_equal)
+ {
+ lexeme_t l = _lexer.current();
- _lexer.next();
+ _lexer.next();
xpath_ast_node* expr = parse_relational_expression();
- n = new (alloc_node()) xpath_ast_node(l == lex_equal ? ast_op_equal : ast_op_not_equal, xpath_type_boolean, n, expr);
- }
+ n = new (alloc_node()) xpath_ast_node(l == lex_equal ? ast_op_equal : ast_op_not_equal, xpath_type_boolean, n, expr);
+ }
- return n;
- }
-
- // AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
- xpath_ast_node* parse_and_expression()
- {
- xpath_ast_node* n = parse_equality_expression();
+ return n;
+ }
+
+ // AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
+ xpath_ast_node* parse_and_expression()
+ {
+ xpath_ast_node* n = parse_equality_expression();
- while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("and"))
- {
- _lexer.next();
+ while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("and"))
+ {
+ _lexer.next();
xpath_ast_node* expr = parse_equality_expression();
- n = new (alloc_node()) xpath_ast_node(ast_op_and, xpath_type_boolean, n, expr);
- }
+ n = new (alloc_node()) xpath_ast_node(ast_op_and, xpath_type_boolean, n, expr);
+ }
- return n;
- }
+ return n;
+ }
- // OrExpr ::= AndExpr | OrExpr 'or' AndExpr
- xpath_ast_node* parse_or_expression()
- {
- xpath_ast_node* n = parse_and_expression();
+ // OrExpr ::= AndExpr | OrExpr 'or' AndExpr
+ xpath_ast_node* parse_or_expression()
+ {
+ xpath_ast_node* n = parse_and_expression();
- while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("or"))
- {
- _lexer.next();
+ while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("or"))
+ {
+ _lexer.next();
xpath_ast_node* expr = parse_and_expression();
- n = new (alloc_node()) xpath_ast_node(ast_op_or, xpath_type_boolean, n, expr);
- }
+ n = new (alloc_node()) xpath_ast_node(ast_op_or, xpath_type_boolean, n, expr);
+ }
- return n;
- }
+ return n;
+ }
// Expr ::= OrExpr
xpath_ast_node* parse_expression()
@@ -9575,13 +9575,13 @@ PUGI__NS_BEGIN
}
};
- struct xpath_query_impl
- {
+ struct xpath_query_impl
+ {
static xpath_query_impl* create()
{
void* memory = xml_memory::allocate(sizeof(xpath_query_impl));
- return new (memory) xpath_query_impl();
+ return new (memory) xpath_query_impl();
}
static void destroy(void* ptr)
@@ -9595,15 +9595,15 @@ PUGI__NS_BEGIN
xml_memory::deallocate(ptr);
}
- xpath_query_impl(): root(0), alloc(&block)
- {
- block.next = 0;
- }
+ xpath_query_impl(): root(0), alloc(&block)
+ {
+ block.next = 0;
+ }
- xpath_ast_node* root;
- xpath_allocator alloc;
- xpath_memory_block block;
- };
+ xpath_ast_node* root;
+ xpath_allocator alloc;
+ xpath_memory_block block;
+ };
PUGI__FN xpath_string evaluate_string_impl(xpath_query_impl* impl, const xpath_node& n, xpath_stack_data& sd)
{
@@ -9665,9 +9665,9 @@ namespace pugi
return _attribute ? _node : _node.parent();
}
- PUGI__FN static void unspecified_bool_xpath_node(xpath_node***)
- {
- }
+ PUGI__FN static void unspecified_bool_xpath_node(xpath_node***)
+ {
+ }
PUGI__FN xpath_node::operator xpath_node::unspecified_bool_type() const
{
@@ -9813,14 +9813,14 @@ namespace pugi
return impl::xpath_first(_begin, _end, _type);
}
- PUGI__FN xpath_parse_result::xpath_parse_result(): error("Internal error"), offset(0)
- {
- }
+ PUGI__FN xpath_parse_result::xpath_parse_result(): error("Internal error"), offset(0)
+ {
+ }
- PUGI__FN xpath_parse_result::operator bool() const
- {
- return error == 0;
- }
+ PUGI__FN xpath_parse_result::operator bool() const
+ {
+ return error == 0;
+ }
PUGI__FN const char* xpath_parse_result::description() const
{
@@ -9828,8 +9828,8 @@ namespace pugi
}
PUGI__FN xpath_variable::xpath_variable()
- {
- }
+ {
+ }
PUGI__FN const char_t* xpath_variable::name() const
{
@@ -10025,7 +10025,7 @@ namespace pugi
{
#ifdef PUGIXML_NO_EXCEPTIONS
_result.error = "Out of memory";
- #else
+ #else
throw std::bad_alloc();
#endif
}
@@ -10037,7 +10037,7 @@ namespace pugi
if (qimpl->root)
{
- _impl = static_cast<impl::xpath_query_impl*>(impl_holder.release());
+ _impl = static_cast<impl::xpath_query_impl*>(impl_holder.release());
_result.error = 0;
}
}
@@ -10101,13 +10101,13 @@ namespace pugi
size_t full_size = r.length() + 1;
if (capacity > 0)
- {
- size_t size = (full_size < capacity) ? full_size : capacity;
- assert(size > 0);
+ {
+ size_t size = (full_size < capacity) ? full_size : capacity;
+ assert(size > 0);
- memcpy(buffer, r.c_str(), (size - 1) * sizeof(char_t));
- buffer[size - 1] = 0;
- }
+ memcpy(buffer, r.c_str(), (size - 1) * sizeof(char_t));
+ buffer[size - 1] = 0;
+ }
return full_size;
}
@@ -10116,7 +10116,7 @@ namespace pugi
{
if (!_impl) return xpath_node_set();
- impl::xpath_ast_node* root = static_cast<impl::xpath_query_impl*>(_impl)->root;
+ impl::xpath_ast_node* root = static_cast<impl::xpath_query_impl*>(_impl)->root;
if (root->rettype() != xpath_type_node_set)
{
@@ -10147,9 +10147,9 @@ namespace pugi
return _result;
}
- PUGI__FN static void unspecified_bool_xpath_query(xpath_query***)
- {
- }
+ PUGI__FN static void unspecified_bool_xpath_query(xpath_query***)
+ {
+ }
PUGI__FN xpath_query::operator xpath_query::unspecified_bool_type() const
{
@@ -10193,13 +10193,13 @@ namespace pugi
// #endif
#ifdef __BORLANDC__
-# pragma option pop
+# pragma option pop
#endif
// Intel C++ does not properly keep warning state for function templates,
// so popping warning state at the end of translation unit leads to warnings in the middle.
#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
-# pragma warning(pop)
+# pragma warning(pop)
#endif
// Undefine all local macros (makes sure we're not leaking macros in header-only mode)
diff --git a/src/pugixml.hpp b/src/pugixml.hpp
index 708a43b..24c2ded 100644
--- a/src/pugixml.hpp
+++ b/src/pugixml.hpp
@@ -13,7 +13,7 @@
#ifndef PUGIXML_VERSION
// Define version macro; evaluates to major * 100 + minor so that it's safe to use in less-than comparisons
-# define PUGIXML_VERSION 100
+# define PUGIXML_VERSION 100
#endif
// Include user configuration file (this can define various configuration macros)
@@ -32,9 +32,9 @@
// Include STL headers
#ifndef PUGIXML_NO_STL
-# include <iterator>
-# include <iosfwd>
-# include <string>
+# include <iterator>
+# include <iosfwd>
+# include <string>
#endif
// Macro for deprecated features
@@ -50,17 +50,17 @@
// If no API is defined, assume default
#ifndef PUGIXML_API
-# define PUGIXML_API
+# define PUGIXML_API
#endif
// If no API for classes is defined, assume default
#ifndef PUGIXML_CLASS
-# define PUGIXML_CLASS PUGIXML_API
+# define PUGIXML_CLASS PUGIXML_API
#endif
// If no API for functions is defined, assume default
#ifndef PUGIXML_FUNCTION
-# define PUGIXML_FUNCTION PUGIXML_API
+# define PUGIXML_FUNCTION PUGIXML_API
#endif
// Character interface macros
@@ -89,7 +89,7 @@ namespace pugi
// Tree node types
enum xml_node_type
{
- node_null, // Empty (null) node handle
+ node_null, // Empty (null) node handle
node_document, // A document tree's absolute root
node_element, // Element tag, i.e. '<node/>'
node_pcdata, // Plain character data, i.e. 'text'
@@ -97,13 +97,13 @@ namespace pugi
node_comment, // Comment tag, i.e. '<!-- text -->'
node_pi, // Processing instruction, i.e. '<?name?>'
node_declaration, // Document declaration, i.e. '<?xml version="1.0"?>'
- node_doctype // Document type declaration, i.e. '<!DOCTYPE doc>'
+ node_doctype // Document type declaration, i.e. '<!DOCTYPE doc>'
};
// Parsing options
// Minimal parsing mode (equivalent to turning all other flags off).
- // Only elements and PCDATA sections are added to the DOM tree, no text conversions are performed.
+ // Only elements and PCDATA sections are added to the DOM tree, no text conversions are performed.
const unsigned int parse_minimal = 0x0000;
// This flag determines if processing instructions (node_pi) are added to the DOM tree. This flag is off by default.
@@ -116,7 +116,7 @@ namespace pugi
const unsigned int parse_cdata = 0x0004;
// This flag determines if plain character data (node_pcdata) that consist only of whitespace are added to the DOM tree.
- // This flag is off by default; turning it on usually results in slower parsing and more memory consumption.
+ // This flag is off by default; turning it on usually results in slower parsing and more memory consumption.
const unsigned int parse_ws_pcdata = 0x0008;
// This flag determines if character and entity references are expanded during parsing. This flag is on by default.
@@ -125,46 +125,46 @@ namespace pugi
// This flag determines if EOL characters are normalized (converted to #xA) during parsing. This flag is on by default.
const unsigned int parse_eol = 0x0020;
- // This flag determines if attribute values are normalized using CDATA normalization rules during parsing. This flag is on by default.
- const unsigned int parse_wconv_attribute = 0x0040;
+ // This flag determines if attribute values are normalized using CDATA normalization rules during parsing. This flag is on by default.
+ const unsigned int parse_wconv_attribute = 0x0040;
- // This flag determines if attribute values are normalized using NMTOKENS normalization rules during parsing. This flag is off by default.
- const unsigned int parse_wnorm_attribute = 0x0080;
+ // This flag determines if attribute values are normalized using NMTOKENS normalization rules during parsing. This flag is off by default.
+ const unsigned int parse_wnorm_attribute = 0x0080;
- // This flag determines if document declaration (node_declaration) is added to the DOM tree. This flag is off by default.
+ // This flag determines if document declaration (node_declaration) is added to the DOM tree. This flag is off by default.
const unsigned int parse_declaration = 0x0100;
- // This flag determines if document type declaration (node_doctype) is added to the DOM tree. This flag is off by default.
+ // This flag determines if document type declaration (node_doctype) is added to the DOM tree. This flag is off by default.
const unsigned int parse_doctype = 0x0200;
// This flag determines if plain character data (node_pcdata) that is the only child of the parent node and that consists only
- // of whitespace is added to the DOM tree.
- // This flag is off by default; turning it on may result in slower parsing and more memory consumption.
+ // of whitespace is added to the DOM tree.
+ // This flag is off by default; turning it on may result in slower parsing and more memory consumption.
const unsigned int parse_ws_pcdata_single = 0x0400;
// The default parsing mode.
- // Elements, PCDATA and CDATA sections are added to the DOM tree, character/reference entities are expanded,
- // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
+ // Elements, PCDATA and CDATA sections are added to the DOM tree, character/reference entities are expanded,
+ // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
const unsigned int parse_default = parse_cdata | parse_escapes | parse_wconv_attribute | parse_eol;
- // The full parsing mode.
- // Nodes of all types are added to the DOM tree, character/reference entities are expanded,
- // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
- const unsigned int parse_full = parse_default | parse_pi | parse_comments | parse_declaration | parse_doctype;
+ // The full parsing mode.
+ // Nodes of all types are added to the DOM tree, character/reference entities are expanded,
+ // End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
+ const unsigned int parse_full = parse_default | parse_pi | parse_comments | parse_declaration | parse_doctype;
// These flags determine the encoding of input data for XML document
enum xml_encoding
{
- encoding_auto, // Auto-detect input encoding using BOM or < / <? detection; use UTF8 if BOM is not found
- encoding_utf8, // UTF8 encoding
- encoding_utf16_le, // Little-endian UTF16
- encoding_utf16_be, // Big-endian UTF16
- encoding_utf16, // UTF16 with native endianness
- encoding_utf32_le, // Little-endian UTF32
- encoding_utf32_be, // Big-endian UTF32
- encoding_utf32, // UTF32 with native endianness
- encoding_wchar, // The same encoding wchar_t has (either UTF16 or UTF32)
- encoding_latin1
+ encoding_auto, // Auto-detect input encoding using BOM or < / <? detection; use UTF8 if BOM is not found
+ encoding_utf8, // UTF8 encoding
+ encoding_utf16_le, // Little-endian UTF16
+ encoding_utf16_be, // Big-endian UTF16
+ encoding_utf16, // UTF16 with native endianness
+ encoding_utf32_le, // Little-endian UTF32
+ encoding_utf32_be, // Big-endian UTF32
+ encoding_utf32, // UTF32 with native endianness
+ encoding_wchar, // The same encoding wchar_t has (either UTF16 or UTF32)
+ encoding_latin1
};
// Formatting flags
@@ -181,14 +181,14 @@ namespace pugi
// Omit default XML declaration even if there is no declaration in the document. This flag is off by default.
const unsigned int format_no_declaration = 0x08;
- // Don't escape attribute values and PCDATA contents. This flag is off by default.
- const unsigned int format_no_escapes = 0x10;
+ // Don't escape attribute values and PCDATA contents. This flag is off by default.
+ const unsigned int format_no_escapes = 0x10;
- // Open file using text mode in xml_document::save_file. This enables special character (i.e. new-line) conversions on some systems. This flag is off by default.
- const unsigned int format_save_file_text = 0x20;
+ // Open file using text mode in xml_document::save_file. This enables special character (i.e. new-line) conversions on some systems. This flag is off by default.
+ const unsigned int format_save_file_text = 0x20;
// The default set of formatting flags.
- // Nodes are indented depending on their depth in DOM tree, a default declaration is output if document has none.
+ // Nodes are indented depending on their depth in DOM tree, a default declaration is output if document has none.
const unsigned int format_default = format_indent;
// Forward declarations
@@ -197,13 +197,13 @@ namespace pugi
class xml_node_iterator;
class xml_attribute_iterator;
- class xml_named_node_iterator;
+ class xml_named_node_iterator;
class xml_tree_walker;
class xml_node;
- class xml_text;
+ class xml_text;
#ifndef PUGIXML_NO_XPATH
class xpath_node;
@@ -212,22 +212,22 @@ namespace pugi
class xpath_variable_set;
#endif
- // Range-based for loop support
- template <typename It> class xml_object_range
- {
- public:
- typedef It const_iterator;
+ // Range-based for loop support
+ template <typename It> class xml_object_range
+ {
+ public:
+ typedef It const_iterator;
- xml_object_range(It b, It e): _begin(b), _end(e)
- {
- }
+ xml_object_range(It b, It e): _begin(b), _end(e)
+ {
+ }
- It begin() const { return _begin; }
- It end() const { return _end; }
+ It begin() const { return _begin; }
+ It end() const { return _end; }
- private:
- It _begin, _end;
- };
+ private:
+ It _begin, _end;
+ };
// Writer interface for node printing (see xml_node::print)
class PUGIXML_CLASS xml_writer
@@ -243,7 +243,7 @@ namespace pugi
class PUGIXML_CLASS xml_writer_file: public xml_writer
{
public:
- // Construct writer from a FILE* object; void* is used to avoid header dependencies on stdio
+ // Construct writer from a FILE* object; void* is used to avoid header dependencies on stdio
xml_writer_file(void* file);
virtual void write(const void* data, size_t size);
@@ -257,7 +257,7 @@ namespace pugi
class PUGIXML_CLASS xml_writer_stream: public xml_writer
{
public:
- // Construct writer from an output stream object
+ // Construct writer from an output stream object
xml_writer_stream(std::basic_ostream<char, std::char_traits<char> >& stream);
xml_writer_stream(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream);
@@ -278,20 +278,20 @@ namespace pugi
private:
xml_attribute_struct* _attr;
- typedef void (*unspecified_bool_type)(xml_attribute***);
+ typedef void (*unspecified_bool_type)(xml_attribute***);
public:
- // Default constructor. Constructs an empty attribute.
+ // Default constructor. Constructs an empty attribute.
xml_attribute();
- // Constructs attribute from internal pointer
+ // Constructs attribute from internal pointer
explicit xml_attribute(xml_attribute_struct* attr);
- // Safe bool conversion operator
- operator unspecified_bool_type() const;
+ // Safe bool conversion operator
+ operator unspecified_bool_type() const;
- // Borland C++ workaround
- bool operator!() const;
+ // Borland C++ workaround
+ bool operator!() const;
// Comparison operators (compares wrapped attribute pointers)
bool operator==(const xml_attribute& r) const;
@@ -309,7 +309,7 @@ namespace pugi
const char_t* value() const;
// Get attribute value, or the default value if attribute is empty
- const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
+ const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
// Get attribute value as a number, or the default value if conversion did not succeed or attribute is empty
int as_int(int def = 0) const;
@@ -317,14 +317,14 @@ namespace pugi
double as_double(double def = 0) const;
float as_float(float def = 0) const;
- // Get attribute value as bool (returns true if first character is in '1tTyY' set), or the default value if attribute is empty
+ // Get attribute value as bool (returns true if first character is in '1tTyY' set), or the default value if attribute is empty
bool as_bool(bool def = false) const;
- // Set attribute name/value (returns false if attribute is empty or there is not enough memory)
+ // Set attribute name/value (returns false if attribute is empty or there is not enough memory)
bool set_name(const char_t* rhs);
bool set_value(const char_t* rhs);
- // Set attribute value with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
+ // Set attribute value with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
bool set_value(int rhs);
bool set_value(unsigned int rhs);
bool set_value(double rhs);
@@ -337,12 +337,12 @@ namespace pugi
xml_attribute& operator=(double rhs);
xml_attribute& operator=(bool rhs);
- // Get next/previous attribute in the attribute list of the parent node
- xml_attribute next_attribute() const;
- xml_attribute previous_attribute() const;
+ // Get next/previous attribute in the attribute list of the parent node
+ xml_attribute next_attribute() const;
+ xml_attribute previous_attribute() const;
- // Get hash value (unique for handles to the same object)
- size_t hash_value() const;
+ // Get hash value (unique for handles to the same object)
+ size_t hash_value() const;
// Get internal pointer
xml_attribute_struct* internal_object() const;
@@ -363,16 +363,16 @@ namespace pugi
protected:
xml_node_struct* _root;
- typedef void (*unspecified_bool_type)(xml_node***);
+ typedef void (*unspecified_bool_type)(xml_node***);
public:
// Default constructor. Constructs an empty node.
xml_node();
- // Constructs node from internal pointer
+ // Constructs node from internal pointer
explicit xml_node(xml_node_struct* p);
- // Safe bool conversion operator
+ // Safe bool conversion operator
operator unspecified_bool_type() const;
// Borland C++ workaround
@@ -398,24 +398,24 @@ namespace pugi
// Get attribute list
xml_attribute first_attribute() const;
- xml_attribute last_attribute() const;
+ xml_attribute last_attribute() const;
- // Get children list
+ // Get children list
xml_node first_child() const;
- xml_node last_child() const;
+ xml_node last_child() const;
- // Get next/previous sibling in the children list of the parent node
+ // Get next/previous sibling in the children list of the parent node
xml_node next_sibling() const;
xml_node previous_sibling() const;
- // Get parent node
+ // Get parent node
xml_node parent() const;
// Get root of DOM tree this node belongs to
xml_node root() const;
- // Get text object for the current node
- xml_text text() const;
+ // Get text object for the current node
+ xml_text text() const;
// Get child, attribute or next/previous sibling with the specified name
xml_node child(const char_t* name) const;
@@ -491,8 +491,8 @@ namespace pugi
for (xml_node node = first_child(); node; node = node.next_sibling())
if (pred(node))
return node;
-
- return xml_node();
+
+ return xml_node();
}
// Find node from subtree using predicate. Returns first node from subtree (depth-first), for which predicate returned true.
@@ -565,16 +565,16 @@ namespace pugi
attribute_iterator attributes_begin() const;
attribute_iterator attributes_end() const;
- // Range-based for support
- xml_object_range<xml_node_iterator> children() const;
- xml_object_range<xml_named_node_iterator> children(const char_t* name) const;
- xml_object_range<xml_attribute_iterator> attributes() const;
+ // Range-based for support
+ xml_object_range<xml_node_iterator> children() const;
+ xml_object_range<xml_named_node_iterator> children(const char_t* name) const;
+ xml_object_range<xml_attribute_iterator> attributes() const;
// Get node offset in parsed file/string (in char_t units) for debugging purposes
ptrdiff_t offset_debug() const;
- // Get hash value (unique for handles to the same object)
- size_t hash_value() const;
+ // Get hash value (unique for handles to the same object)
+ size_t hash_value() const;
// Get internal pointer
xml_node_struct* internal_object() const;
@@ -586,29 +586,29 @@ namespace pugi
bool PUGIXML_FUNCTION operator||(const xml_node& lhs, bool rhs);
#endif
- // A helper for working with text inside PCDATA nodes
- class PUGIXML_CLASS xml_text
- {
- friend class xml_node;
+ // A helper for working with text inside PCDATA nodes
+ class PUGIXML_CLASS xml_text
+ {
+ friend class xml_node;
- xml_node_struct* _root;
+ xml_node_struct* _root;
- typedef void (*unspecified_bool_type)(xml_text***);
+ typedef void (*unspecified_bool_type)(xml_text***);
- explicit xml_text(xml_node_struct* root);
+ explicit xml_text(xml_node_struct* root);
- xml_node_struct* _data_new();
- xml_node_struct* _data() const;
+ xml_node_struct* _data_new();
+ xml_node_struct* _data() const;
- public:
- // Default constructor. Constructs an empty object.
- xml_text();
+ public:
+ // Default constructor. Constructs an empty object.
+ xml_text();
- // Safe bool conversion operator
- operator unspecified_bool_type() const;
+ // Safe bool conversion operator
+ operator unspecified_bool_type() const;
- // Borland C++ workaround
- bool operator!() const;
+ // Borland C++ workaround
+ bool operator!() const;
// Check if text object is empty
bool empty() const;
@@ -617,7 +617,7 @@ namespace pugi
const char_t* get() const;
// Get text, or the default value if object is empty
- const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
+ const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
// Get text as a number, or the default value if conversion did not succeed or object is empty
int as_int(int def = 0) const;
@@ -625,13 +625,13 @@ namespace pugi
double as_double(double def = 0) const;
float as_float(float def = 0) const;
- // Get text as bool (returns true if first character is in '1tTyY' set), or the default value if object is empty
+ // Get text as bool (returns true if first character is in '1tTyY' set), or the default value if object is empty
bool as_bool(bool def = false) const;
- // Set text (returns false if object is empty or there is not enough memory)
+ // Set text (returns false if object is empty or there is not enough memory)
bool set(const char_t* rhs);
- // Set text with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
+ // Set text with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
bool set(int rhs);
bool set(unsigned int rhs);
bool set(double rhs);
@@ -644,9 +644,9 @@ namespace pugi
xml_text& operator=(double rhs);
xml_text& operator=(bool rhs);
- // Get the data node (node_pcdata or node_cdata) for this object
- xml_node data() const;
- };
+ // Get the data node (node_pcdata or node_cdata) for this object
+ xml_node data() const;
+ };
#ifdef __BORLANDC__
// Borland C++ workaround
@@ -676,13 +676,13 @@ namespace pugi
typedef std::bidirectional_iterator_tag iterator_category;
#endif
- // Default constructor
+ // Default constructor
xml_node_iterator();
- // Construct an iterator which points to the specified node
+ // Construct an iterator which points to the specified node
xml_node_iterator(const xml_node& node);
- // Iterator operators
+ // Iterator operators
bool operator==(const xml_node_iterator& rhs) const;
bool operator!=(const xml_node_iterator& rhs) const;
@@ -718,10 +718,10 @@ namespace pugi
typedef std::bidirectional_iterator_tag iterator_category;
#endif
- // Default constructor
+ // Default constructor
xml_attribute_iterator();
- // Construct an iterator which points to the specified attribute
+ // Construct an iterator which points to the specified attribute
xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent);
// Iterator operators
@@ -738,40 +738,40 @@ namespace pugi
xml_attribute_iterator operator--(int);
};
- // Named node range helper
- class xml_named_node_iterator
- {
- public:
- // Iterator traits
- typedef ptrdiff_t difference_type;
- typedef xml_node value_type;
- typedef xml_node* pointer;
- typedef xml_node& reference;
+ // Named node range helper
+ class xml_named_node_iterator
+ {
+ public:
+ // Iterator traits
+ typedef ptrdiff_t difference_type;
+ typedef xml_node value_type;
+ typedef xml_node* pointer;
+ typedef xml_node& reference;
- #ifndef PUGIXML_NO_STL
- typedef std::forward_iterator_tag iterator_category;
- #endif
+ #ifndef PUGIXML_NO_STL
+ typedef std::forward_iterator_tag iterator_category;
+ #endif
- // Default constructor
- xml_named_node_iterator();
+ // Default constructor
+ xml_named_node_iterator();
- // Construct an iterator which points to the specified node
- xml_named_node_iterator(const xml_node& node, const char_t* name);
+ // Construct an iterator which points to the specified node
+ xml_named_node_iterator(const xml_node& node, const char_t* name);
- // Iterator operators
- bool operator==(const xml_named_node_iterator& rhs) const;
- bool operator!=(const xml_named_node_iterator& rhs) const;
+ // Iterator operators
+ bool operator==(const xml_named_node_iterator& rhs) const;
+ bool operator!=(const xml_named_node_iterator& rhs) const;
- xml_node& operator*() const;
- xml_node* operator->() const;
+ xml_node& operator*() const;
+ xml_node* operator->() const;
- const xml_named_node_iterator& operator++();
- xml_named_node_iterator operator++(int);
+ const xml_named_node_iterator& operator++();
+ xml_named_node_iterator operator++(int);
- private:
- mutable xml_node _node;
- const char_t* _name;
- };
+ private:
+ mutable xml_node _node;
+ const char_t* _name;
+ };
// Abstract tree walker class (see xml_node::traverse)
class PUGIXML_CLASS xml_tree_walker
@@ -802,23 +802,23 @@ namespace pugi
// Parsing status, returned as part of xml_parse_result object
enum xml_parse_status
{
- status_ok = 0, // No error
-
- status_file_not_found, // File was not found during load_file()
- status_io_error, // Error reading from file/stream
- status_out_of_memory, // Could not allocate memory
- status_internal_error, // Internal error occurred
-
- status_unrecognized_tag, // Parser could not determine tag type
-
- status_bad_pi, // Parsing error occurred while parsing document declaration/processing instruction
- status_bad_comment, // Parsing error occurred while parsing comment
- status_bad_cdata, // Parsing error occurred while parsing CDATA section
- status_bad_doctype, // Parsing error occurred while parsing document type declaration
- status_bad_pcdata, // Parsing error occurred while parsing PCDATA section
- status_bad_start_element, // Parsing error occurred while parsing start element tag
- status_bad_attribute, // Parsing error occurred while parsing element attribute
- status_bad_end_element, // Parsing error occurred while parsing end element tag
+ status_ok = 0, // No error
+
+ status_file_not_found, // File was not found during load_file()
+ status_io_error, // Error reading from file/stream
+ status_out_of_memory, // Could not allocate memory
+ status_internal_error, // Internal error occurred
+
+ status_unrecognized_tag, // Parser could not determine tag type
+
+ status_bad_pi, // Parsing error occurred while parsing document declaration/processing instruction
+ status_bad_comment, // Parsing error occurred while parsing comment
+ status_bad_cdata, // Parsing error occurred while parsing CDATA section
+ status_bad_doctype, // Parsing error occurred while parsing document type declaration
+ status_bad_pcdata, // Parsing error occurred while parsing PCDATA section
+ status_bad_start_element, // Parsing error occurred while parsing start element tag
+ status_bad_attribute, // Parsing error occurred while parsing element attribute
+ status_bad_end_element, // Parsing error occurred while parsing end element tag
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)
};
@@ -834,7 +834,7 @@ namespace pugi
// Source document encoding
xml_encoding encoding;
- // Default constructor, initializes object to failed state
+ // Default constructor, initializes object to failed state
xml_parse_result();
// Cast to bool operator
@@ -868,10 +868,10 @@ namespace pugi
// Destructor, invalidates all node/attribute handles to this document
~xml_document();
- // Removes all nodes, leaving the empty document
+ // Removes all nodes, leaving the empty document
void reset();
- // Removes all nodes, then copies the entire contents of the specified document
+ // Removes all nodes, then copies the entire contents of the specified document
void reset(const xml_document& proto);
#ifndef PUGIXML_NO_STL
@@ -891,11 +891,11 @@ namespace pugi
xml_parse_result load_buffer(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
// Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
- // You should ensure that buffer data will persist throughout the document's lifetime, and free the buffer memory manually once document is destroyed.
+ // You should ensure that buffer data will persist throughout the document's lifetime, and free the buffer memory manually once document is destroyed.
xml_parse_result load_buffer_inplace(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
// Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
- // 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).
+ // 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).
xml_parse_result load_buffer_inplace_own(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
// Save XML document to writer (semantics is slightly different from xml_node::print, see documentation for details).
@@ -911,22 +911,22 @@ namespace pugi
bool save_file(const char* path, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
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;
- // Get document element
- xml_node document_element() const;
+ // Get document element
+ xml_node document_element() const;
};
#ifndef PUGIXML_NO_XPATH
// XPath query return type
enum xpath_value_type
{
- xpath_type_none, // Unknown type (query failed to compile)
+ xpath_type_none, // Unknown type (query failed to compile)
xpath_type_node_set, // Node set (xpath_node_set)
- xpath_type_number, // Number
- xpath_type_string, // String
- xpath_type_boolean // Boolean
+ xpath_type_number, // Number
+ xpath_type_string, // String
+ xpath_type_boolean // Boolean
};
- // XPath parsing result
+ // XPath parsing result
struct PUGIXML_CLASS xpath_parse_result
{
// Error message (0 if no error)
@@ -935,7 +935,7 @@ namespace pugi
// Last parsed offset (in char_t units from string start)
ptrdiff_t offset;
- // Default constructor, initializes object to failed state
+ // Default constructor, initializes object to failed state
xpath_parse_result();
// Cast to bool operator
@@ -961,19 +961,19 @@ namespace pugi
xpath_variable& operator=(const xpath_variable&);
public:
- // Get variable name
+ // Get variable name
const char_t* name() const;
- // Get variable type
+ // Get variable type
xpath_value_type type() const;
- // Get variable value; no type conversion is performed, default value (false, NaN, empty string, empty node set) is returned on type mismatch error
+ // Get variable value; no type conversion is performed, default value (false, NaN, empty string, empty node set) is returned on type mismatch error
bool get_boolean() const;
double get_number() const;
const char_t* get_string() const;
const xpath_node_set& get_node_set() const;
- // Set variable value; no type conversion is performed, false is returned on type mismatch error
+ // Set variable value; no type conversion is performed, false is returned on type mismatch error
bool set(bool value);
bool set(double value);
bool set(const char_t* value);
@@ -993,20 +993,20 @@ namespace pugi
xpath_variable* find(const char_t* name) const;
public:
- // Default constructor/destructor
+ // Default constructor/destructor
xpath_variable_set();
~xpath_variable_set();
- // Add a new variable or get the existing one, if the types match
+ // Add a new variable or get the existing one, if the types match
xpath_variable* add(const char_t* name, xpath_value_type type);
- // Set value of an existing variable; no type conversion is performed, false is returned if there is no such variable or if types mismatch
+ // Set value of an existing variable; no type conversion is performed, false is returned if there is no such variable or if types mismatch
bool set(const char_t* name, bool value);
bool set(const char_t* name, double value);
bool set(const char_t* name, const char_t* value);
bool set(const char_t* name, const xpath_node_set& value);
- // Get existing variable by name
+ // Get existing variable by name
xpath_variable* get(const char_t* name);
const xpath_variable* get(const char_t* name) const;
};
@@ -1018,15 +1018,15 @@ namespace pugi
void* _impl;
xpath_parse_result _result;
- typedef void (*unspecified_bool_type)(xpath_query***);
+ typedef void (*unspecified_bool_type)(xpath_query***);
// Non-copyable semantics
xpath_query(const xpath_query&);
xpath_query& operator=(const xpath_query&);
public:
- // Construct a compiled object from XPath expression.
- // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on compilation errors.
+ // Construct a compiled object from XPath expression.
+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on compilation errors.
explicit xpath_query(const char_t* query, xpath_variable_set* variables = 0);
// Destructor
@@ -1036,28 +1036,28 @@ namespace pugi
xpath_value_type return_type() const;
// Evaluate expression as boolean value in the specified context; performs type conversion if necessary.
- // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
bool evaluate_boolean(const xpath_node& n) const;
// Evaluate expression as double value in the specified context; performs type conversion if necessary.
- // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
double evaluate_number(const xpath_node& n) const;
#ifndef PUGIXML_NO_STL
// Evaluate expression as string value in the specified context; performs type conversion if necessary.
- // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
string_t evaluate_string(const xpath_node& n) const;
#endif
// Evaluate expression as string value in the specified context; performs type conversion if necessary.
- // At most capacity characters are written to the destination buffer, full result size is returned (includes terminating zero).
- // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
- // If PUGIXML_NO_EXCEPTIONS is defined, returns empty set instead.
+ // At most capacity characters are written to the destination buffer, full result size is returned (includes terminating zero).
+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+ // If PUGIXML_NO_EXCEPTIONS is defined, returns empty set instead.
size_t evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const;
// Evaluate expression as node set in the specified context.
- // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on type mismatch and std::bad_alloc on out of memory errors.
- // If PUGIXML_NO_EXCEPTIONS is defined, returns empty node set instead.
+ // If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on type mismatch and std::bad_alloc on out of memory errors.
+ // If PUGIXML_NO_EXCEPTIONS is defined, returns empty node set instead.
xpath_node_set evaluate_node_set(const xpath_node& n) const;
// Get parsing result (used to get compilation errors in PUGIXML_NO_EXCEPTIONS mode)
@@ -1066,7 +1066,7 @@ namespace pugi
// Safe bool conversion operator
operator unspecified_bool_type() const;
- // Borland C++ workaround
+ // Borland C++ workaround
bool operator!() const;
};
@@ -1084,7 +1084,7 @@ namespace pugi
// Get error message
virtual const char* what() const throw();
- // Get parse result
+ // Get parse result
const xpath_parse_result& result() const;
};
#endif
@@ -1096,7 +1096,7 @@ namespace pugi
xml_node _node;
xml_attribute _attribute;
- typedef void (*unspecified_bool_type)(xpath_node***);
+ typedef void (*unspecified_bool_type)(xpath_node***);
public:
// Default constructor; constructs empty XPath node
@@ -1113,11 +1113,11 @@ namespace pugi
// Get parent of contained node/attribute
xml_node parent() const;
- // Safe bool conversion operator
+ // Safe bool conversion operator
operator unspecified_bool_type() const;
- // Borland C++ workaround
- bool operator!() const;
+ // Borland C++ workaround
+ bool operator!() const;
// Comparison operators
bool operator==(const xpath_node& n) const;
@@ -1164,7 +1164,7 @@ namespace pugi
// Get collection size
size_t size() const;
- // Indexing operator
+ // Indexing operator
const xpath_node& operator[](size_t index) const;
// Collection iterators
@@ -1179,7 +1179,7 @@ namespace pugi
// Check if collection is empty
bool empty() const;
-
+
private:
type_t _type;
@@ -1206,14 +1206,14 @@ namespace pugi
typedef void* (*allocation_function)(size_t size);
// Memory deallocation function interface
- typedef void (*deallocation_function)(void* ptr);
-
- // Override default memory management functions. All subsequent allocations/deallocations will be performed via supplied functions.
- void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate);
-
- // Get current memory management functions
- allocation_function PUGIXML_FUNCTION get_memory_allocation_function();
- deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function();
+ typedef void (*deallocation_function)(void* ptr);
+
+ // Override default memory management functions. All subsequent allocations/deallocations will be performed via supplied functions.
+ void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate);
+
+ // Get current memory management functions
+ allocation_function PUGIXML_FUNCTION get_memory_allocation_function();
+ deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function();
}
#if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) || defined(__ICC))