diff options
| -rw-r--r-- | src/pugixml.cpp | 1822 | ||||
| -rw-r--r-- | src/pugixml.hpp | 422 |
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)) |