From 141d26d3af9f32a06b5f1473609ad164bd21123d Mon Sep 17 00:00:00 2001 From: "arseny.kapoulkine" Date: Fri, 11 Jun 2010 19:01:40 +0000 Subject: Minor refactoring (moved unicode utilities to anonymous namespace, moved decode functions to templated class to work around function instantiation bugs, removed optN_to_type) git-svn-id: http://pugixml.googlecode.com/svn/trunk@511 99668b35-9821-0410-8761-19e4c4f06640 --- src/pugixml.cpp | 497 +++++++++++++++++++++++++++----------------------------- 1 file changed, 240 insertions(+), 257 deletions(-) diff --git a/src/pugixml.cpp b/src/pugixml.cpp index 758d951..242202e 100644 --- a/src/pugixml.cpp +++ b/src/pugixml.cpp @@ -593,191 +593,205 @@ namespace } } +// Helper classes for code generation +namespace +{ + struct opt_false + { + enum { value = 0 }; + }; + + struct opt_true + { + enum { value = 1 }; + }; +} + // Unicode utilities -namespace pugi +namespace { - namespace impl + inline uint16_t endian_swap(uint16_t value) { - inline uint16_t endian_swap(uint16_t value) - { - return static_cast(((value & 0xff) << 8) | (value >> 8)); - } + return static_cast(((value & 0xff) << 8) | (value >> 8)); + } + + inline uint32_t endian_swap(uint32_t value) + { + return ((value & 0xff) << 24) | ((value & 0xff00) << 8) | ((value & 0xff0000) >> 8) | (value >> 24); + } + + struct utf8_counter + { + typedef size_t value_type; - inline uint32_t endian_swap(uint32_t value) + static value_type low(value_type result, uint32_t ch) { - return ((value & 0xff) << 24) | ((value & 0xff00) << 8) | ((value & 0xff0000) >> 8) | (value >> 24); + // U+0000..U+007F + if (ch < 0x80) return result + 1; + // U+0080..U+07FF + else if (ch < 0x800) return result + 2; + // U+0800..U+FFFF + else return result + 3; } - struct utf8_counter + static value_type high(value_type result, uint32_t) { - typedef size_t value_type; - - static value_type low(value_type result, uint32_t ch) - { - // U+0000..U+007F - if (ch < 0x80) return result + 1; - // U+0080..U+07FF - else if (ch < 0x800) return result + 2; - // U+0800..U+FFFF - else return result + 3; - } + // U+10000..U+10FFFF + return result + 4; + } + }; - static value_type high(value_type result, uint32_t) - { - // U+10000..U+10FFFF - return result + 4; - } - }; + struct utf8_writer + { + typedef uint8_t* value_type; - struct utf8_writer + static value_type low(value_type result, uint32_t ch) { - typedef uint8_t* value_type; - - static value_type low(value_type result, uint32_t ch) + // U+0000..U+007F + if (ch < 0x80) { - // U+0000..U+007F - if (ch < 0x80) - { - *result = static_cast(ch); - return result + 1; - } - // U+0080..U+07FF - else if (ch < 0x800) - { - result[0] = static_cast(0xC0 | (ch >> 6)); - result[1] = static_cast(0x80 | (ch & 0x3F)); - return result + 2; - } - // U+0800..U+FFFF - else - { - result[0] = static_cast(0xE0 | (ch >> 12)); - result[1] = static_cast(0x80 | ((ch >> 6) & 0x3F)); - result[2] = static_cast(0x80 | (ch & 0x3F)); - return result + 3; - } + *result = static_cast(ch); + return result + 1; } - - static value_type high(value_type result, uint32_t ch) + // U+0080..U+07FF + else if (ch < 0x800) { - // U+10000..U+10FFFF - result[0] = static_cast(0xF0 | (ch >> 18)); - result[1] = static_cast(0x80 | ((ch >> 12) & 0x3F)); - result[2] = static_cast(0x80 | ((ch >> 6) & 0x3F)); - result[3] = static_cast(0x80 | (ch & 0x3F)); - return result + 4; + result[0] = static_cast(0xC0 | (ch >> 6)); + result[1] = static_cast(0x80 | (ch & 0x3F)); + return result + 2; } - - static value_type any(value_type result, uint32_t ch) + // U+0800..U+FFFF + else { - return (ch < 0x10000) ? low(result, ch) : high(result, ch); + result[0] = static_cast(0xE0 | (ch >> 12)); + result[1] = static_cast(0x80 | ((ch >> 6) & 0x3F)); + result[2] = static_cast(0x80 | (ch & 0x3F)); + return result + 3; } - }; + } - struct utf16_counter + static value_type high(value_type result, uint32_t ch) { - typedef size_t value_type; + // U+10000..U+10FFFF + result[0] = static_cast(0xF0 | (ch >> 18)); + result[1] = static_cast(0x80 | ((ch >> 12) & 0x3F)); + result[2] = static_cast(0x80 | ((ch >> 6) & 0x3F)); + result[3] = static_cast(0x80 | (ch & 0x3F)); + return result + 4; + } - static value_type low(value_type result, uint32_t) - { - return result + 1; - } + static value_type any(value_type result, uint32_t ch) + { + return (ch < 0x10000) ? low(result, ch) : high(result, ch); + } + }; - static value_type high(value_type result, uint32_t) - { - return result + 2; - } - }; + struct utf16_counter + { + typedef size_t value_type; - struct utf16_writer + static value_type low(value_type result, uint32_t) { - typedef uint16_t* value_type; + return result + 1; + } - static value_type low(value_type result, uint32_t ch) - { - *result = static_cast(ch); + static value_type high(value_type result, uint32_t) + { + return result + 2; + } + }; - return result + 1; - } + struct utf16_writer + { + typedef uint16_t* value_type; - static value_type high(value_type result, uint32_t ch) - { - uint32_t msh = (uint32_t)(ch - 0x10000) >> 10; - uint32_t lsh = (uint32_t)(ch - 0x10000) & 0x3ff; + static value_type low(value_type result, uint32_t ch) + { + *result = static_cast(ch); - result[0] = static_cast(0xD800 + msh); - result[1] = static_cast(0xDC00 + lsh); + return result + 1; + } - return result + 2; - } + static value_type high(value_type result, uint32_t ch) + { + uint32_t msh = (uint32_t)(ch - 0x10000) >> 10; + uint32_t lsh = (uint32_t)(ch - 0x10000) & 0x3ff; - static value_type any(value_type result, uint32_t ch) - { - return (ch < 0x10000) ? low(result, ch) : high(result, ch); - } - }; + result[0] = static_cast(0xD800 + msh); + result[1] = static_cast(0xDC00 + lsh); - struct utf32_counter + return result + 2; + } + + static value_type any(value_type result, uint32_t ch) { - typedef size_t value_type; + return (ch < 0x10000) ? low(result, ch) : high(result, ch); + } + }; - static value_type low(value_type result, uint32_t) - { - return result + 1; - } + struct utf32_counter + { + typedef size_t value_type; - static value_type high(value_type result, uint32_t) - { - return result + 1; - } - }; + static value_type low(value_type result, uint32_t) + { + return result + 1; + } - struct utf32_writer + static value_type high(value_type result, uint32_t) { - typedef uint32_t* value_type; + return result + 1; + } + }; - static value_type low(value_type result, uint32_t ch) - { - *result = ch; + struct utf32_writer + { + typedef uint32_t* value_type; - return result + 1; - } + static value_type low(value_type result, uint32_t ch) + { + *result = ch; - static value_type high(value_type result, uint32_t ch) - { - *result = ch; + return result + 1; + } - return result + 1; - } + static value_type high(value_type result, uint32_t ch) + { + *result = ch; - static value_type any(value_type result, uint32_t ch) - { - *result = ch; + return result + 1; + } - return result + 1; - } - }; + static value_type any(value_type result, uint32_t ch) + { + *result = ch; - template struct wchar_selector; + return result + 1; + } + }; - template <> struct wchar_selector<2> - { - typedef uint16_t type; - typedef utf16_counter counter; - typedef utf16_writer writer; - }; + template struct wchar_selector; - template <> struct wchar_selector<4> - { - typedef uint32_t type; - typedef utf32_counter counter; - typedef utf32_writer writer; - }; + template <> struct wchar_selector<2> + { + typedef uint16_t type; + typedef utf16_counter counter; + typedef utf16_writer writer; + }; + + template <> struct wchar_selector<4> + { + typedef uint32_t type; + typedef utf32_counter counter; + typedef utf32_writer writer; + }; - typedef wchar_selector::counter wchar_counter; - typedef wchar_selector::writer wchar_writer; + typedef wchar_selector::counter wchar_counter; + typedef wchar_selector::writer wchar_writer; - template static inline typename Traits::value_type decode_utf8_block(const uint8_t* data, size_t size, typename Traits::value_type result, Traits = Traits()) + template struct utf_decoder + { + static inline typename Traits::value_type decode_utf8_block(const uint8_t* data, size_t size, typename Traits::value_type result) { const uint8_t utf8_byte_mask = 0x3f; @@ -838,15 +852,13 @@ namespace pugi return result; } - template static inline typename Traits::value_type decode_utf16_block(const uint16_t* data, size_t size, typename Traits::value_type result, opt1, Traits = Traits()) + static inline typename Traits::value_type decode_utf16_block(const uint16_t* data, size_t size, typename Traits::value_type result) { - const bool swap = opt1::o1; - const uint16_t* end = data + size; while (data < end) { - uint16_t lead = swap ? endian_swap(*data) : *data; + uint16_t lead = opt_swap::value ? endian_swap(*data) : *data; // U+0000..U+D7FF if (lead < 0xD800) @@ -863,7 +875,7 @@ namespace pugi // surrogate pair lead else if ((unsigned)(lead - 0xD800) < 0x400 && data + 1 < end) { - uint16_t next = swap ? endian_swap(data[1]) : data[1]; + uint16_t next = opt_swap::value ? endian_swap(data[1]) : data[1]; if ((unsigned)(next - 0xDC00) < 0x400) { @@ -884,15 +896,13 @@ namespace pugi return result; } - template static inline typename Traits::value_type decode_utf32_block(const uint32_t* data, size_t size, typename Traits::value_type result, opt1, Traits = Traits()) + static inline typename Traits::value_type decode_utf32_block(const uint32_t* data, size_t size, typename Traits::value_type result) { - const bool swap = opt1::o1; - const uint32_t* end = data + size; while (data < end) { - uint32_t lead = swap ? endian_swap(*data) : *data; + uint32_t lead = opt_swap::value ? endian_swap(*data) : *data; // U+0000..U+FFFF if (lead < 0x10000) @@ -910,16 +920,16 @@ namespace pugi return result; } + }; - template inline void convert_utf_endian_swap(T* result, const T* data, size_t length) - { - for (size_t i = 0; i < length; ++i) result[i] = endian_swap(data[i]); - } + template inline void convert_utf_endian_swap(T* result, const T* data, size_t length) + { + for (size_t i = 0; i < length; ++i) result[i] = endian_swap(data[i]); + } - inline void convert_wchar_endian_swap(wchar_t* result, const wchar_t* data, size_t length) - { - for (size_t i = 0; i < length; ++i) result[i] = static_cast(endian_swap(static_cast::type>(data[i]))); - } + inline void convert_wchar_endian_swap(wchar_t* result, const wchar_t* data, size_t length) + { + for (size_t i = 0; i < length; ++i) result[i] = static_cast(endian_swap(static_cast::type>(data[i]))); } } @@ -1000,22 +1010,6 @@ namespace #define IS_OUTPUT_CHARTYPE(c, ct) (output_chartype_table[static_cast(c)] & (ct)) #endif - template struct opt1_to_type - { - static const bool o1; - }; - - template const bool opt1_to_type<_1>::o1 = _1; - - template struct opt2_to_type - { - static const bool o1; - static const bool o2; - }; - - template const bool opt2_to_type<_1, _2>::o1 = _1; - template const bool opt2_to_type<_1, _2>::o2 = _2; - bool is_little_endian() { unsigned int ui = 1; @@ -1116,7 +1110,7 @@ namespace out_length = size / sizeof(char_t); - impl::convert_wchar_endian_swap(out_buffer, data, out_length); + convert_wchar_endian_swap(out_buffer, data, out_length); return true; } @@ -1126,15 +1120,15 @@ namespace const uint8_t* data = static_cast(contents); // first pass: get length in wchar_t units - out_length = impl::decode_utf8_block(data, size, 0); + out_length = utf_decoder::decode_utf8_block(data, size, 0); // allocate buffer of suitable length out_buffer = static_cast(global_allocate((out_length > 0 ? out_length : 1) * sizeof(char_t))); if (!out_buffer) return false; // second pass: convert utf8 input to wchar_t - impl::wchar_writer::value_type out_begin = reinterpret_cast(out_buffer); - impl::wchar_writer::value_type out_end = impl::decode_utf8_block(data, size, out_begin); + wchar_writer::value_type out_begin = reinterpret_cast(out_buffer); + wchar_writer::value_type out_end = utf_decoder::decode_utf8_block(data, size, out_begin); assert(out_end == out_begin + out_length); (void)!out_end; @@ -1142,21 +1136,21 @@ namespace return true; } - template bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt1) + template bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) { const uint16_t* data = static_cast(contents); size_t length = size / sizeof(uint16_t); // first pass: get length in wchar_t units - out_length = impl::decode_utf16_block(data, length, 0, opt1()); + out_length = utf_decoder::decode_utf16_block(data, length, 0); // allocate buffer of suitable length out_buffer = static_cast(global_allocate((out_length > 0 ? out_length : 1) * sizeof(char_t))); if (!out_buffer) return false; // second pass: convert utf16 input to wchar_t - impl::wchar_writer::value_type out_begin = reinterpret_cast(out_buffer); - impl::wchar_writer::value_type out_end = impl::decode_utf16_block(data, length, out_begin, opt1()); + wchar_writer::value_type out_begin = reinterpret_cast(out_buffer); + wchar_writer::value_type out_end = utf_decoder::decode_utf16_block(data, length, out_begin); assert(out_end == out_begin + out_length); (void)!out_end; @@ -1164,21 +1158,21 @@ namespace return true; } - template bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt1) + template bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) { const uint32_t* data = static_cast(contents); size_t length = size / sizeof(uint32_t); // first pass: get length in wchar_t units - out_length = impl::decode_utf32_block(data, length, 0, opt1()); + out_length = utf_decoder::decode_utf32_block(data, length, 0); // allocate buffer of suitable length out_buffer = static_cast(global_allocate((out_length > 0 ? out_length : 1) * sizeof(char_t))); if (!out_buffer) return false; // second pass: convert utf32 input to wchar_t - impl::wchar_writer::value_type out_begin = reinterpret_cast(out_buffer); - impl::wchar_writer::value_type out_end = impl::decode_utf32_block(data, length, out_begin, opt1()); + wchar_writer::value_type out_begin = reinterpret_cast(out_buffer); + wchar_writer::value_type out_end = utf_decoder::decode_utf32_block(data, length, out_begin); assert(out_end == out_begin + out_length); (void)!out_end; @@ -1206,8 +1200,8 @@ namespace encoding_t native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be; return (native_encoding == encoding) ? - convert_buffer_utf16(out_buffer, out_length, contents, size, opt1_to_type()) : - convert_buffer_utf16(out_buffer, out_length, contents, size, opt1_to_type()); + convert_buffer_utf16(out_buffer, out_length, contents, size, opt_false()) : + convert_buffer_utf16(out_buffer, out_length, contents, size, opt_true()); } // source encoding is utf32 @@ -1216,8 +1210,8 @@ namespace encoding_t native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be; return (native_encoding == encoding) ? - convert_buffer_utf32(out_buffer, out_length, contents, size, opt1_to_type()) : - convert_buffer_utf32(out_buffer, out_length, contents, size, opt1_to_type()); + convert_buffer_utf32(out_buffer, out_length, contents, size, opt_false()) : + convert_buffer_utf32(out_buffer, out_length, contents, size, opt_true()); } // invalid encoding combination (this can't happen) @@ -1226,13 +1220,13 @@ namespace return false; } #else - template bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt1) + template bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) { const uint16_t* data = static_cast(contents); size_t length = size / sizeof(uint16_t); // first pass: get length in utf8 units - out_length = impl::decode_utf16_block(data, length, 0, opt1()); + out_length = utf_decoder::decode_utf16_block(data, length, 0); // allocate buffer of suitable length out_buffer = static_cast(global_allocate((out_length > 0 ? out_length : 1) * sizeof(char_t))); @@ -1240,7 +1234,7 @@ namespace // second pass: convert utf16 input to utf8 uint8_t* out_begin = reinterpret_cast(out_buffer); - uint8_t* out_end = impl::decode_utf16_block(data, length, out_begin, opt1()); + uint8_t* out_end = utf_decoder::decode_utf16_block(data, length, out_begin); assert(out_end == out_begin + out_length); (void)!out_end; @@ -1248,13 +1242,13 @@ namespace return true; } - template bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt1) + template bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap) { const uint32_t* data = static_cast(contents); size_t length = size / sizeof(uint32_t); // first pass: get length in utf8 units - out_length = impl::decode_utf32_block(data, length, 0, opt1()); + out_length = utf_decoder::decode_utf32_block(data, length, 0); // allocate buffer of suitable length out_buffer = static_cast(global_allocate((out_length > 0 ? out_length : 1) * sizeof(char_t))); @@ -1262,7 +1256,7 @@ namespace // second pass: convert utf32 input to utf8 uint8_t* out_begin = reinterpret_cast(out_buffer); - uint8_t* out_end = impl::decode_utf32_block(data, length, out_begin, opt1()); + uint8_t* out_end = utf_decoder::decode_utf32_block(data, length, out_begin); assert(out_end == out_begin + out_length); (void)!out_end; @@ -1281,8 +1275,8 @@ namespace encoding_t native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be; return (native_encoding == encoding) ? - convert_buffer_utf16(out_buffer, out_length, contents, size, opt1_to_type()) : - convert_buffer_utf16(out_buffer, out_length, contents, size, opt1_to_type()); + convert_buffer_utf16(out_buffer, out_length, contents, size, opt_false()) : + convert_buffer_utf16(out_buffer, out_length, contents, size, opt_true()); } // source encoding is utf32 @@ -1291,8 +1285,8 @@ namespace encoding_t native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be; return (native_encoding == encoding) ? - convert_buffer_utf32(out_buffer, out_length, contents, size, opt1_to_type()) : - convert_buffer_utf32(out_buffer, out_length, contents, size, opt1_to_type()); + convert_buffer_utf32(out_buffer, out_length, contents, size, opt_false()) : + convert_buffer_utf32(out_buffer, out_length, contents, size, opt_true()); } // invalid encoding combination (this can't happen) @@ -1415,9 +1409,9 @@ namespace } #ifdef PUGIXML_WCHAR_MODE - s = reinterpret_cast(impl::wchar_writer::any(reinterpret_cast(s), ucsc)); + s = reinterpret_cast(wchar_writer::any(reinterpret_cast(s), ucsc)); #else - s = reinterpret_cast(impl::utf8_writer::any(reinterpret_cast(s), ucsc)); + s = reinterpret_cast(utf8_writer::any(reinterpret_cast(s), ucsc)); #endif g.push(s, stre - s); @@ -1557,13 +1551,10 @@ namespace typedef char_t* (*strconv_pcdata_t)(char_t*); - template struct strconv_pcdata_impl + template struct strconv_pcdata_impl { static char_t* parse(char_t* s) { - const bool opt_eol = opt2::o1; - const bool opt_escape = opt2::o2; - gap g; while (true) @@ -1576,13 +1567,13 @@ namespace return s + 1; } - else if (opt_eol && *s == '\r') // Either a single 0x0d or 0x0d 0x0a pair + else if (opt_eol::value && *s == '\r') // Either a single 0x0d or 0x0d 0x0a pair { *s++ = '\n'; // replace first one with 0x0a if (*s == '\n') g.push(s, 1); } - else if (opt_escape && *s == '&') + else if (opt_escape::value && *s == '&') { s = strconv_escape(s, g); } @@ -1601,22 +1592,20 @@ namespace switch ((optmask >> 4) & 3) // get bitmask for flags (eol escapes) { - case 0: return strconv_pcdata_impl >::parse; - case 1: return strconv_pcdata_impl >::parse; - case 2: return strconv_pcdata_impl >::parse; - case 3: return strconv_pcdata_impl >::parse; + case 0: return strconv_pcdata_impl::parse; + case 1: return strconv_pcdata_impl::parse; + case 2: return strconv_pcdata_impl::parse; + case 3: return strconv_pcdata_impl::parse; default: return 0; // should not get here } } typedef char_t* (*strconv_attribute_t)(char_t*, char_t); - template struct strconv_attribute_impl + template struct strconv_attribute_impl { static char_t* parse_wnorm(char_t* s, char_t end_quote) { - const bool opt_escape = opt1::o1; - gap g; // trim leading whitespaces @@ -1655,7 +1644,7 @@ namespace g.push(s, str - s); } } - else if (opt_escape && *s == '&') + else if (opt_escape::value && *s == '&') { s = strconv_escape(s, g); } @@ -1669,8 +1658,6 @@ namespace static char_t* parse_wconv(char_t* s, char_t end_quote) { - const bool opt_escape = opt1::o1; - gap g; while (true) @@ -1693,7 +1680,7 @@ namespace } else *s++ = ' '; } - else if (opt_escape && *s == '&') + else if (opt_escape::value && *s == '&') { s = strconv_escape(s, g); } @@ -1707,8 +1694,6 @@ namespace static char_t* parse_eol(char_t* s, char_t end_quote) { - const bool opt_escape = opt1::o1; - gap g; while (true) @@ -1727,7 +1712,7 @@ namespace if (*s == '\n') g.push(s, 1); } - else if (opt_escape && *s == '&') + else if (opt_escape::value && *s == '&') { s = strconv_escape(s, g); } @@ -1741,8 +1726,6 @@ namespace static char_t* parse_simple(char_t* s, char_t end_quote) { - const bool opt_escape = opt1::o1; - gap g; while (true) @@ -1755,7 +1738,7 @@ namespace return s + 1; } - else if (opt_escape && *s == '&') + else if (opt_escape::value && *s == '&') { s = strconv_escape(s, g); } @@ -1774,22 +1757,22 @@ namespace switch ((optmask >> 4) & 15) // get bitmask for flags (wconv wnorm eol escapes) { - case 0: return strconv_attribute_impl >::parse_simple; - case 1: return strconv_attribute_impl >::parse_simple; - case 2: return strconv_attribute_impl >::parse_eol; - case 3: return strconv_attribute_impl >::parse_eol; - case 4: return strconv_attribute_impl >::parse_wconv; - case 5: return strconv_attribute_impl >::parse_wconv; - case 6: return strconv_attribute_impl >::parse_wconv; - case 7: return strconv_attribute_impl >::parse_wconv; - case 8: return strconv_attribute_impl >::parse_wnorm; - case 9: return strconv_attribute_impl >::parse_wnorm; - case 10: return strconv_attribute_impl >::parse_wnorm; - case 11: return strconv_attribute_impl >::parse_wnorm; - case 12: return strconv_attribute_impl >::parse_wnorm; - case 13: return strconv_attribute_impl >::parse_wnorm; - case 14: return strconv_attribute_impl >::parse_wnorm; - case 15: return strconv_attribute_impl >::parse_wnorm; + case 0: return strconv_attribute_impl::parse_simple; + case 1: return strconv_attribute_impl::parse_simple; + case 2: return strconv_attribute_impl::parse_eol; + case 3: return strconv_attribute_impl::parse_eol; + case 4: return strconv_attribute_impl::parse_wconv; + case 5: return strconv_attribute_impl::parse_wconv; + case 6: return strconv_attribute_impl::parse_wconv; + case 7: return strconv_attribute_impl::parse_wconv; + case 8: return strconv_attribute_impl::parse_wnorm; + case 9: return strconv_attribute_impl::parse_wnorm; + case 10: return strconv_attribute_impl::parse_wnorm; + case 11: return strconv_attribute_impl::parse_wnorm; + case 12: return strconv_attribute_impl::parse_wnorm; + case 13: return strconv_attribute_impl::parse_wnorm; + case 14: return strconv_attribute_impl::parse_wnorm; + case 15: return strconv_attribute_impl::parse_wnorm; default: return 0; // should not get here } } @@ -2461,7 +2444,7 @@ namespace // only endian-swapping is required if (need_endian_swap_utf(encoding, get_wchar_encoding())) { - impl::convert_wchar_endian_swap(reinterpret_cast(result), data, length); + convert_wchar_endian_swap(reinterpret_cast(result), data, length); return length * sizeof(char_t); } @@ -2472,8 +2455,8 @@ namespace uint8_t* dest = reinterpret_cast(result); uint8_t* end = sizeof(wchar_t) == 2 ? - impl::decode_utf16_block(reinterpret_cast(data), length, dest, opt1_to_type()) : - impl::decode_utf32_block(reinterpret_cast(data), length, dest, opt1_to_type()); + utf_decoder::decode_utf16_block(reinterpret_cast(data), length, dest) : + utf_decoder::decode_utf32_block(reinterpret_cast(data), length, dest); return static_cast(end - dest); } @@ -2484,12 +2467,12 @@ namespace uint16_t* dest = reinterpret_cast(result); // convert to native utf16 - uint16_t* end = impl::decode_utf32_block(reinterpret_cast(data), length, dest, opt1_to_type()); + uint16_t* end = utf_decoder::decode_utf32_block(reinterpret_cast(data), length, dest); // swap if necessary encoding_t native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be; - if (native_encoding != encoding) impl::convert_utf_endian_swap(dest, dest, static_cast(end - dest)); + if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast(end - dest)); return static_cast(end - dest) * sizeof(uint16_t); } @@ -2500,12 +2483,12 @@ namespace uint32_t* dest = reinterpret_cast(result); // convert to native utf32 - uint32_t* end = impl::decode_utf16_block(reinterpret_cast(data), length, dest, opt1_to_type()); + uint32_t* end = utf_decoder::decode_utf16_block(reinterpret_cast(data), length, dest); // swap if necessary encoding_t native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be; - if (native_encoding != encoding) impl::convert_utf_endian_swap(dest, dest, static_cast(end - dest)); + if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast(end - dest)); return static_cast(end - dest) * sizeof(uint32_t); } @@ -2539,12 +2522,12 @@ namespace uint16_t* dest = reinterpret_cast(result); // convert to native utf16 - uint16_t* end = impl::decode_utf8_block(reinterpret_cast(data), length, dest); + uint16_t* end = utf_decoder::decode_utf8_block(reinterpret_cast(data), length, dest); // swap if necessary encoding_t native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be; - if (native_encoding != encoding) impl::convert_utf_endian_swap(dest, dest, static_cast(end - dest)); + if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast(end - dest)); return static_cast(end - dest) * sizeof(uint16_t); } @@ -2554,12 +2537,12 @@ namespace uint32_t* dest = reinterpret_cast(result); // convert to native utf32 - uint32_t* end = impl::decode_utf8_block(reinterpret_cast(data), length, dest); + uint32_t* end = utf_decoder::decode_utf8_block(reinterpret_cast(data), length, dest); // swap if necessary encoding_t native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be; - if (native_encoding != encoding) impl::convert_utf_endian_swap(dest, dest, static_cast(end - dest)); + if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast(end - dest)); return static_cast(end - dest) * sizeof(uint32_t); } @@ -4468,8 +4451,8 @@ namespace pugi // first pass: get length in utf8 characters size_t size = sizeof(wchar_t) == 2 ? - impl::decode_utf16_block(reinterpret_cast(str), length, 0, opt1_to_type()) : - impl::decode_utf32_block(reinterpret_cast(str), length, 0, opt1_to_type()); + utf_decoder::decode_utf16_block(reinterpret_cast(str), length, 0) : + utf_decoder::decode_utf32_block(reinterpret_cast(str), length, 0); // allocate resulting string std::string result; @@ -4480,8 +4463,8 @@ namespace pugi { uint8_t* begin = reinterpret_cast(&result[0]); uint8_t* end = sizeof(wchar_t) == 2 ? - impl::decode_utf16_block(reinterpret_cast(str), length, begin, opt1_to_type()) : - impl::decode_utf32_block(reinterpret_cast(str), length, begin, opt1_to_type()); + utf_decoder::decode_utf16_block(reinterpret_cast(str), length, begin) : + utf_decoder::decode_utf32_block(reinterpret_cast(str), length, begin); // truncate invalid output assert(begin <= end && static_cast(end - begin) <= result.size()); @@ -4502,7 +4485,7 @@ namespace pugi size_t size = strlen(str); // first pass: get length in wchar_t - size_t length = impl::decode_utf8_block(data, size, 0); + size_t length = utf_decoder::decode_utf8_block(data, size, 0); // allocate resulting string std::wstring result; @@ -4511,8 +4494,8 @@ namespace pugi // second pass: convert to wchar_t if (length > 0) { - impl::wchar_writer::value_type begin = reinterpret_cast(&result[0]); - impl::wchar_writer::value_type end = impl::decode_utf8_block(data, size, begin); + wchar_writer::value_type begin = reinterpret_cast(&result[0]); + wchar_writer::value_type end = utf_decoder::decode_utf8_block(data, size, begin); // truncate invalid output assert(begin <= end && static_cast(end - begin) <= result.size()); -- cgit v1.2.3