6 * Use, modification and distribution are subject to the
7 * Boost Software License, Version 1.0. (See accompanying file
8 * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
13 * LOCATION: see http://www.boost.org for most recent version.
14 * FILE unicode_iterator.hpp
15 * VERSION see <boost/version.hpp>
16 * DESCRIPTION: Iterator adapters for converting between different Unicode encodings.
19 /****************************************************************************
24 1) Read Only, Input Adapters:
25 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27 template <class BaseIterator, class U8Type = ::boost::uint8_t>
28 class u32_to_u8_iterator;
30 Adapts sequence of UTF-32 code points to "look like" a sequence of UTF-8.
32 template <class BaseIterator, class U32Type = ::boost::uint32_t>
33 class u8_to_u32_iterator;
35 Adapts sequence of UTF-8 code points to "look like" a sequence of UTF-32.
37 template <class BaseIterator, class U16Type = ::boost::uint16_t>
38 class u32_to_u16_iterator;
40 Adapts sequence of UTF-32 code points to "look like" a sequence of UTF-16.
42 template <class BaseIterator, class U32Type = ::boost::uint32_t>
43 class u16_to_u32_iterator;
45 Adapts sequence of UTF-16 code points to "look like" a sequence of UTF-32.
47 2) Single pass output iterator adapters:
49 template <class BaseIterator>
50 class utf8_output_iterator;
52 Accepts UTF-32 code points and forwards them on as UTF-8 code points.
54 template <class BaseIterator>
55 class utf16_output_iterator;
57 Accepts UTF-32 code points and forwards them on as UTF-16 code points.
59 ****************************************************************************/
61 #ifndef BOOST_REGEX_UNICODE_ITERATOR_HPP
62 #define BOOST_REGEX_UNICODE_ITERATOR_HPP
63 #include <boost/cstdint.hpp>
64 #include <boost/assert.hpp>
65 #include <boost/iterator/iterator_facade.hpp>
66 #include <boost/static_assert.hpp>
67 #include <boost/throw_exception.hpp>
69 #ifndef BOOST_NO_STD_LOCALE
73 #include <limits.h> // CHAR_BIT
79 static const ::boost::uint16_t high_surrogate_base = 0xD7C0u;
80 static const ::boost::uint16_t low_surrogate_base = 0xDC00u;
81 static const ::boost::uint32_t ten_bit_mask = 0x3FFu;
83 inline bool is_high_surrogate(::boost::uint16_t v)
85 return (v & 0xFC00u) == 0xd800u;
87 inline bool is_low_surrogate(::boost::uint16_t v)
89 return (v & 0xFC00u) == 0xdc00u;
92 inline bool is_surrogate(T v)
94 return (v & 0xF800u) == 0xd800;
97 inline unsigned utf8_byte_count(boost::uint8_t c)
99 // if the most significant bit with a zero in it is in position
100 // 8-N then there are N bytes in this UTF-8 sequence:
101 boost::uint8_t mask = 0x80u;
108 return (result == 0) ? 1 : ((result > 4) ? 4 : result);
111 inline unsigned utf8_trailing_byte_count(boost::uint8_t c)
113 return utf8_byte_count(c) - 1;
117 #pragma warning(push)
118 #pragma warning(disable:4100)
120 inline void invalid_utf32_code_point(::boost::uint32_t val)
122 #ifndef BOOST_NO_STD_LOCALE
123 std::stringstream ss;
124 ss << "Invalid UTF-32 code point U+" << std::showbase << std::hex << val << " encountered while trying to encode UTF-16 sequence";
125 std::out_of_range e(ss.str());
127 std::out_of_range e("Invalid UTF-32 code point encountered while trying to encode UTF-16 sequence");
129 boost::throw_exception(e);
136 } // namespace detail
138 template <class BaseIterator, class U16Type = ::boost::uint16_t>
139 class u32_to_u16_iterator
140 : public boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type>
142 typedef boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type> base_type;
144 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
145 typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
147 BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);
148 BOOST_STATIC_ASSERT(sizeof(U16Type)*CHAR_BIT == 16);
152 typename base_type::reference
157 return m_values[m_current];
159 bool equal(const u32_to_u16_iterator& that)const
161 if(m_position == that.m_position)
163 // Both m_currents must be equal, or both even
164 // this is the same as saying their sum must be even:
165 return (m_current + that.m_current) & 1u ? false : true;
171 // if we have a pending read then read now, so that we know whether
172 // to skip a position, or move to a low-surrogate:
178 // move to the next surrogate position:
180 // if we've reached the end skip a position:
181 if(m_values[m_current] == 0)
191 // decrementing an iterator always leads to a valid position:
194 m_current = m_values[1] ? 1 : 0;
201 BaseIterator base()const
206 u32_to_u16_iterator() : m_position(), m_current(0)
212 u32_to_u16_iterator(BaseIterator b) : m_position(b), m_current(2)
220 void extract_current()const
222 // begin by checking for a code point out of range:
223 ::boost::uint32_t v = *m_position;
227 detail::invalid_utf32_code_point(*m_position);
228 // split into two surrogates:
229 m_values[0] = static_cast<U16Type>(v >> 10) + detail::high_surrogate_base;
230 m_values[1] = static_cast<U16Type>(v & detail::ten_bit_mask) + detail::low_surrogate_base;
232 BOOST_ASSERT(detail::is_high_surrogate(m_values[0]));
233 BOOST_ASSERT(detail::is_low_surrogate(m_values[1]));
237 // 16-bit code point:
238 m_values[0] = static_cast<U16Type>(*m_position);
241 // value must not be a surrogate:
242 if(detail::is_surrogate(m_values[0]))
243 detail::invalid_utf32_code_point(*m_position);
246 BaseIterator m_position;
247 mutable U16Type m_values[3];
248 mutable unsigned m_current;
251 template <class BaseIterator, class U32Type = ::boost::uint32_t>
252 class u16_to_u32_iterator
253 : public boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>
255 typedef boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;
256 // special values for pending iterator reads:
257 BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);
259 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
260 typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
262 BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 16);
263 BOOST_STATIC_ASSERT(sizeof(U32Type)*CHAR_BIT == 32);
267 typename base_type::reference
270 if(m_value == pending_read)
274 bool equal(const u16_to_u32_iterator& that)const
276 return m_position == that.m_position;
280 // skip high surrogate first if there is one:
281 if(detail::is_high_surrogate(*m_position)) ++m_position;
283 m_value = pending_read;
288 // if we have a low surrogate then go back one more:
289 if(detail::is_low_surrogate(*m_position))
291 m_value = pending_read;
293 BaseIterator base()const
298 u16_to_u32_iterator() : m_position()
300 m_value = pending_read;
302 u16_to_u32_iterator(BaseIterator b) : m_position(b)
304 m_value = pending_read;
307 static void invalid_code_point(::boost::uint16_t val)
309 #ifndef BOOST_NO_STD_LOCALE
310 std::stringstream ss;
311 ss << "Misplaced UTF-16 surrogate U+" << std::showbase << std::hex << val << " encountered while trying to encode UTF-32 sequence";
312 std::out_of_range e(ss.str());
314 std::out_of_range e("Misplaced UTF-16 surrogate encountered while trying to encode UTF-32 sequence");
316 boost::throw_exception(e);
318 void extract_current()const
320 m_value = static_cast<U32Type>(static_cast< ::boost::uint16_t>(*m_position));
321 // if the last value is a high surrogate then adjust m_position and m_value as needed:
322 if(detail::is_high_surrogate(*m_position))
324 // precondition; next value must have be a low-surrogate:
325 BaseIterator next(m_position);
326 ::boost::uint16_t t = *++next;
327 if((t & 0xFC00u) != 0xDC00u)
328 invalid_code_point(t);
329 m_value = (m_value - detail::high_surrogate_base) << 10;
330 m_value |= (static_cast<U32Type>(static_cast< ::boost::uint16_t>(t)) & detail::ten_bit_mask);
332 // postcondition; result must not be a surrogate:
333 if(detail::is_surrogate(m_value))
334 invalid_code_point(static_cast< ::boost::uint16_t>(m_value));
336 BaseIterator m_position;
337 mutable U32Type m_value;
340 template <class BaseIterator, class U8Type = ::boost::uint8_t>
341 class u32_to_u8_iterator
342 : public boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type>
344 typedef boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type> base_type;
346 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
347 typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
349 BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);
350 BOOST_STATIC_ASSERT(sizeof(U8Type)*CHAR_BIT == 8);
354 typename base_type::reference
359 return m_values[m_current];
361 bool equal(const u32_to_u8_iterator& that)const
363 if(m_position == that.m_position)
365 // either the m_current's must be equal, or one must be 0 and
366 // the other 4: which means neither must have bits 1 or 2 set:
367 return (m_current == that.m_current)
368 || (((m_current | that.m_current) & 3) == 0);
374 // if we have a pending read then read now, so that we know whether
375 // to skip a position, or move to a low-surrogate:
381 // move to the next surrogate position:
383 // if we've reached the end skip a position:
384 if(m_values[m_current] == 0)
392 if((m_current & 3) == 0)
397 while(m_current && (m_values[m_current] == 0))
403 BaseIterator base()const
408 u32_to_u8_iterator() : m_position(), m_current(0)
416 u32_to_u8_iterator(BaseIterator b) : m_position(b), m_current(4)
426 void extract_current()const
428 boost::uint32_t c = *m_position;
430 detail::invalid_utf32_code_point(c);
433 m_values[0] = static_cast<unsigned char>(c);
434 m_values[1] = static_cast<unsigned char>(0u);
435 m_values[2] = static_cast<unsigned char>(0u);
436 m_values[3] = static_cast<unsigned char>(0u);
440 m_values[0] = static_cast<unsigned char>(0xC0u + (c >> 6));
441 m_values[1] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
442 m_values[2] = static_cast<unsigned char>(0u);
443 m_values[3] = static_cast<unsigned char>(0u);
445 else if(c < 0x10000u)
447 m_values[0] = static_cast<unsigned char>(0xE0u + (c >> 12));
448 m_values[1] = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));
449 m_values[2] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
450 m_values[3] = static_cast<unsigned char>(0u);
454 m_values[0] = static_cast<unsigned char>(0xF0u + (c >> 18));
455 m_values[1] = static_cast<unsigned char>(0x80u + ((c >> 12) & 0x3Fu));
456 m_values[2] = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));
457 m_values[3] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
461 BaseIterator m_position;
462 mutable U8Type m_values[5];
463 mutable unsigned m_current;
466 template <class BaseIterator, class U32Type = ::boost::uint32_t>
467 class u8_to_u32_iterator
468 : public boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>
470 typedef boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;
471 // special values for pending iterator reads:
472 BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);
474 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
475 typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
477 BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 8);
478 BOOST_STATIC_ASSERT(sizeof(U32Type)*CHAR_BIT == 32);
482 typename base_type::reference
485 if(m_value == pending_read)
489 bool equal(const u8_to_u32_iterator& that)const
491 return m_position == that.m_position;
495 // skip high surrogate first if there is one:
496 unsigned c = detail::utf8_byte_count(*m_position);
497 std::advance(m_position, c);
498 m_value = pending_read;
502 // Keep backtracking until we don't have a trailing character:
504 while((*--m_position & 0xC0u) == 0x80u) ++count;
505 // now check that the sequence was valid:
506 if(count != detail::utf8_trailing_byte_count(*m_position))
508 m_value = pending_read;
510 BaseIterator base()const
515 u8_to_u32_iterator() : m_position()
517 m_value = pending_read;
519 u8_to_u32_iterator(BaseIterator b) : m_position(b)
521 m_value = pending_read;
524 static void invalid_sequnce()
526 std::out_of_range e("Invalid UTF-8 sequence encountered while trying to encode UTF-32 character");
527 boost::throw_exception(e);
529 void extract_current()const
531 m_value = static_cast<U32Type>(static_cast< ::boost::uint8_t>(*m_position));
532 // we must not have a continuation character:
533 if((m_value & 0xC0u) == 0x80u)
535 // see how many extra byts we have:
536 unsigned extra = detail::utf8_trailing_byte_count(*m_position);
537 // extract the extra bits, 6 from each extra byte:
538 BaseIterator next(m_position);
539 for(unsigned c = 0; c < extra; ++c)
543 m_value += static_cast<boost::uint8_t>(*next) & 0x3Fu;
545 // we now need to remove a few of the leftmost bits, but how many depends
546 // upon how many extra bytes we've extracted:
547 static const boost::uint32_t masks[4] =
554 m_value &= masks[extra];
556 if(m_value > static_cast<U32Type>(0x10FFFFu))
559 BaseIterator m_position;
560 mutable U32Type m_value;
563 template <class BaseIterator>
564 class utf16_output_iterator
567 typedef void difference_type;
568 typedef void value_type;
569 typedef boost::uint32_t* pointer;
570 typedef boost::uint32_t& reference;
571 typedef std::output_iterator_tag iterator_category;
573 utf16_output_iterator(const BaseIterator& b)
575 utf16_output_iterator(const utf16_output_iterator& that)
576 : m_position(that.m_position){}
577 utf16_output_iterator& operator=(const utf16_output_iterator& that)
579 m_position = that.m_position;
582 const utf16_output_iterator& operator*()const
586 void operator=(boost::uint32_t val)const
590 utf16_output_iterator& operator++()
594 utf16_output_iterator& operator++(int)
598 BaseIterator base()const
603 void push(boost::uint32_t v)const
607 // begin by checking for a code point out of range:
609 detail::invalid_utf32_code_point(v);
610 // split into two surrogates:
611 *m_position++ = static_cast<boost::uint16_t>(v >> 10) + detail::high_surrogate_base;
612 *m_position++ = static_cast<boost::uint16_t>(v & detail::ten_bit_mask) + detail::low_surrogate_base;
616 // 16-bit code point:
617 // value must not be a surrogate:
618 if(detail::is_surrogate(v))
619 detail::invalid_utf32_code_point(v);
620 *m_position++ = static_cast<boost::uint16_t>(v);
623 mutable BaseIterator m_position;
626 template <class BaseIterator>
627 class utf8_output_iterator
630 typedef void difference_type;
631 typedef void value_type;
632 typedef boost::uint32_t* pointer;
633 typedef boost::uint32_t& reference;
634 typedef std::output_iterator_tag iterator_category;
636 utf8_output_iterator(const BaseIterator& b)
638 utf8_output_iterator(const utf8_output_iterator& that)
639 : m_position(that.m_position){}
640 utf8_output_iterator& operator=(const utf8_output_iterator& that)
642 m_position = that.m_position;
645 const utf8_output_iterator& operator*()const
649 void operator=(boost::uint32_t val)const
653 utf8_output_iterator& operator++()
657 utf8_output_iterator& operator++(int)
661 BaseIterator base()const
666 void push(boost::uint32_t c)const
669 detail::invalid_utf32_code_point(c);
672 *m_position++ = static_cast<unsigned char>(c);
676 *m_position++ = static_cast<unsigned char>(0xC0u + (c >> 6));
677 *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
679 else if(c < 0x10000u)
681 *m_position++ = static_cast<unsigned char>(0xE0u + (c >> 12));
682 *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));
683 *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
687 *m_position++ = static_cast<unsigned char>(0xF0u + (c >> 18));
688 *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 12) & 0x3Fu));
689 *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));
690 *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
693 mutable BaseIterator m_position;
698 #endif // BOOST_REGEX_UNICODE_ITERATOR_HPP