1 /*

     2  *

     3  * Copyright (c) 2004

     4  * John Maddock

     5  *

     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)

     9  *

    10  */

    11  

    12  /*

    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.

    17   */

    18 

    19 /****************************************************************************

    20 

    21 Contents:

    22 ~~~~~~~~~

    23 

    24 1) Read Only, Input Adapters:

    25 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    26 

    27 template <class BaseIterator, class U8Type = ::boost::uint8_t>

    28 class u32_to_u8_iterator;

    29 

    30 Adapts sequence of UTF-32 code points to "look like" a sequence of UTF-8.

    31 

    32 template <class BaseIterator, class U32Type = ::boost::uint32_t>

    33 class u8_to_u32_iterator;

    34 

    35 Adapts sequence of UTF-8 code points to "look like" a sequence of UTF-32.

    36 

    37 template <class BaseIterator, class U16Type = ::boost::uint16_t>

    38 class u32_to_u16_iterator;

    39 

    40 Adapts sequence of UTF-32 code points to "look like" a sequence of UTF-16.

    41 

    42 template <class BaseIterator, class U32Type = ::boost::uint32_t>

    43 class u16_to_u32_iterator;

    44 

    45 Adapts sequence of UTF-16 code points to "look like" a sequence of UTF-32.

    46 

    47 2) Single pass output iterator adapters:

    48 

    49 template <class BaseIterator>

    50 class utf8_output_iterator;

    51 

    52 Accepts UTF-32 code points and forwards them on as UTF-8 code points.

    53 

    54 template <class BaseIterator>

    55 class utf16_output_iterator;

    56 

    57 Accepts UTF-32 code points and forwards them on as UTF-16 code points.

    58 

    59 ****************************************************************************/

    60 

    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>

    68 #include <stdexcept>

    69 #ifndef BOOST_NO_STD_LOCALE

    70 #include <sstream>

    71 #include <ios>

    72 #endif

    73 #include <limits.h> // CHAR_BIT

    74 

    75 namespace boost{

    76 

    77 namespace detail{

    78 

    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;

    82 

    83 inline bool is_high_surrogate(::boost::uint16_t v)

    84 {

    85    return (v & 0xFC00u) == 0xd800u;

    86 }

    87 inline bool is_low_surrogate(::boost::uint16_t v)

    88 {

    89    return (v & 0xFC00u) == 0xdc00u;

    90 }

    91 template <class T>

    92 inline bool is_surrogate(T v)

    93 {

    94    return (v & 0xF800u) == 0xd800;

    95 }

    96 

    97 inline unsigned utf8_byte_count(boost::uint8_t c)

    98 {

    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;

   102    unsigned result = 0;

   103    while(c & mask)

   104    {

   105       ++result;

   106       mask >>= 1;

   107    }

   108    return (result == 0) ? 1 : ((result > 4) ? 4 : result);

   109 }

   110 

   111 inline unsigned utf8_trailing_byte_count(boost::uint8_t c)

   112 {

   113    return utf8_byte_count(c) - 1;

   114 }

   115 

   116 inline void invalid_utf32_code_point(::boost::uint32_t val)

   117 {

   118 #ifndef BOOST_NO_STD_LOCALE

   119    std::stringstream ss;

   120    ss << "Invalid UTF-32 code point U+" << std::showbase << std::hex << val << " encountered while trying to encode UTF-16 sequence";

   121    std::out_of_range e(ss.str());

   122 #else

   123    std::out_of_range e("Invalid UTF-32 code point encountered while trying to encode UTF-16 sequence");

   124 #endif

   125    boost::throw_exception(e);

   126 }

   127 

   128 

   129 } // namespace detail

   130 

   131 template <class BaseIterator, class U16Type = ::boost::uint16_t>

   132 class u32_to_u16_iterator

   133    : public boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type>

   134 {

   135    typedef boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type> base_type;

   136 

   137 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

   138    typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

   139 

   140    BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);

   141    BOOST_STATIC_ASSERT(sizeof(U16Type)*CHAR_BIT == 16);

   142 #endif

   143 

   144 public:

   145    typename base_type::reference

   146       dereference()const

   147    {

   148       if(m_current == 2)

   149          extract_current();

   150       return m_values[m_current];

   151    }

   152    bool equal(const u32_to_u16_iterator& that)const

   153    {

   154       if(m_position == that.m_position)

   155       {

   156          // Both m_currents must be equal, or both even

   157          // this is the same as saying their sum must be even:

   158          return (m_current + that.m_current) & 1u ? false : true;

   159       }

   160       return false;

   161    }

   162    void increment()

   163    {

   164       // if we have a pending read then read now, so that we know whether

   165       // to skip a position, or move to a low-surrogate:

   166       if(m_current == 2)

   167       {

   168          // pending read:

   169          extract_current();

   170       }

   171       // move to the next surrogate position:

   172       ++m_current;

   173       // if we've reached the end skip a position:

   174       if(m_values[m_current] == 0)

   175       {

   176          m_current = 2;

   177          ++m_position;

   178       }

   179    }

   180    void decrement()

   181    {

   182       if(m_current != 1)

   183       {

   184          // decrementing an iterator always leads to a valid position:

   185          --m_position;

   186          extract_current();

   187          m_current = m_values[1] ? 1 : 0;

   188       }

   189       else

   190       {

   191          m_current = 0;

   192       }

   193    }

   194    BaseIterator base()const

   195    {

   196       return m_position;

   197    }

   198    // construct:

   199    u32_to_u16_iterator() : m_position(), m_current(0)

   200    {

   201       m_values[0] = 0;

   202       m_values[1] = 0;

   203       m_values[2] = 0;

   204    }

   205    u32_to_u16_iterator(BaseIterator b) : m_position(b), m_current(2)

   206    {

   207       m_values[0] = 0;

   208       m_values[1] = 0;

   209       m_values[2] = 0;

   210    }

   211 private:

   212 

   213    void extract_current()const

   214    {

   215       // begin by checking for a code point out of range:

   216       ::boost::uint32_t v = *m_position;

   217       if(v >= 0x10000u)

   218       {

   219          if(v > 0x10FFFFu)

   220             detail::invalid_utf32_code_point(*m_position);

   221          // split into two surrogates:

   222          m_values[0] = static_cast<U16Type>(v >> 10) + detail::high_surrogate_base;

   223          m_values[1] = static_cast<U16Type>(v & detail::ten_bit_mask) + detail::low_surrogate_base;

   224          m_current = 0;

   225          BOOST_ASSERT(detail::is_high_surrogate(m_values[0]));

   226          BOOST_ASSERT(detail::is_low_surrogate(m_values[1]));

   227       }

   228       else

   229       {

   230          // 16-bit code point:

   231          m_values[0] = static_cast<U16Type>(*m_position);

   232          m_values[1] = 0;

   233          m_current = 0;

   234          // value must not be a surrogate:

   235          if(detail::is_surrogate(m_values[0]))

   236             detail::invalid_utf32_code_point(*m_position);

   237       }

   238    }

   239    BaseIterator m_position;

   240    mutable U16Type m_values[3];

   241    mutable unsigned m_current;

   242 };

   243 

   244 template <class BaseIterator, class U32Type = ::boost::uint32_t>

   245 class u16_to_u32_iterator

   246    : public boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>

   247 {

   248    typedef boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;

   249    // special values for pending iterator reads:

   250    BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);

   251 

   252 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

   253    typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

   254 

   255    BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 16);

   256    BOOST_STATIC_ASSERT(sizeof(U32Type)*CHAR_BIT == 32);

   257 #endif

   258 

   259 public:

   260    typename base_type::reference

   261       dereference()const

   262    {

   263       if(m_value == pending_read)

   264          extract_current();

   265       return m_value;

   266    }

   267    bool equal(const u16_to_u32_iterator& that)const

   268    {

   269       return m_position == that.m_position;

   270    }

   271    void increment()

   272    {

   273       // skip high surrogate first if there is one:

   274       if(detail::is_high_surrogate(*m_position)) ++m_position;

   275       ++m_position;

   276       m_value = pending_read;

   277    }

   278    void decrement()

   279    {

   280       --m_position;

   281       // if we have a low surrogate then go back one more:

   282       if(detail::is_low_surrogate(*m_position)) 

   283          --m_position;

   284       m_value = pending_read;

   285    }

   286    BaseIterator base()const

   287    {

   288       return m_position;

   289    }

   290    // construct:

   291    u16_to_u32_iterator() : m_position()

   292    {

   293       m_value = pending_read;

   294    }

   295    u16_to_u32_iterator(BaseIterator b) : m_position(b)

   296    {

   297       m_value = pending_read;

   298    }

   299 private:

   300    static void invalid_code_point(::boost::uint16_t val)

   301    {

   302 #ifndef BOOST_NO_STD_LOCALE

   303       std::stringstream ss;

   304       ss << "Misplaced UTF-16 surrogate U+" << std::showbase << std::hex << val << " encountered while trying to encode UTF-32 sequence";

   305       std::out_of_range e(ss.str());

   306 #else

   307       std::out_of_range e("Misplaced UTF-16 surrogate encountered while trying to encode UTF-32 sequence");

   308 #endif

   309       boost::throw_exception(e);

   310    }

   311    void extract_current()const

   312    {

   313       m_value = static_cast<U32Type>(static_cast< ::boost::uint16_t>(*m_position));

   314       // if the last value is a high surrogate then adjust m_position and m_value as needed:

   315       if(detail::is_high_surrogate(*m_position))

   316       {

   317          // precondition; next value must have be a low-surrogate:

   318          BaseIterator next(m_position);

   319          ::boost::uint16_t t = *++next;

   320          if((t & 0xFC00u) != 0xDC00u)

   321             invalid_code_point(t);

   322          m_value = (m_value - detail::high_surrogate_base) << 10;

   323          m_value |= (static_cast<U32Type>(static_cast< ::boost::uint16_t>(t)) & detail::ten_bit_mask);

   324       }

   325       // postcondition; result must not be a surrogate:

   326       if(detail::is_surrogate(m_value))

   327          invalid_code_point(static_cast< ::boost::uint16_t>(m_value));

   328    }

   329    BaseIterator m_position;

   330    mutable U32Type m_value;

   331 };

   332 

   333 template <class BaseIterator, class U8Type = ::boost::uint8_t>

   334 class u32_to_u8_iterator

   335    : public boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type>

   336 {

   337    typedef boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type> base_type;

   338    

   339 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

   340    typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

   341 

   342    BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);

   343    BOOST_STATIC_ASSERT(sizeof(U8Type)*CHAR_BIT == 8);

   344 #endif

   345 

   346 public:

   347    typename base_type::reference

   348       dereference()const

   349    {

   350       if(m_current == 4)

   351          extract_current();

   352       return m_values[m_current];

   353    }

   354    bool equal(const u32_to_u8_iterator& that)const

   355    {

   356       if(m_position == that.m_position)

   357       {

   358          // either the m_current's must be equal, or one must be 0 and 

   359          // the other 4: which means neither must have bits 1 or 2 set:

   360          return (m_current == that.m_current)

   361             || (((m_current | that.m_current) & 3) == 0);

   362       }

   363       return false;

   364    }

   365    void increment()

   366    {

   367       // if we have a pending read then read now, so that we know whether

   368       // to skip a position, or move to a low-surrogate:

   369       if(m_current == 4)

   370       {

   371          // pending read:

   372          extract_current();

   373       }

   374       // move to the next surrogate position:

   375       ++m_current;

   376       // if we've reached the end skip a position:

   377       if(m_values[m_current] == 0)

   378       {

   379          m_current = 4;

   380          ++m_position;

   381       }

   382    }

   383    void decrement()

   384    {

   385       if((m_current & 3) == 0)

   386       {

   387          --m_position;

   388          extract_current();

   389          m_current = 3;

   390          while(m_current && (m_values[m_current] == 0))

   391             --m_current;

   392       }

   393       else

   394          --m_current;

   395    }

   396    BaseIterator base()const

   397    {

   398       return m_position;

   399    }

   400    // construct:

   401    u32_to_u8_iterator() : m_position(), m_current(0)

   402    {

   403       m_values[0] = 0;

   404       m_values[1] = 0;

   405       m_values[2] = 0;

   406       m_values[3] = 0;

   407       m_values[4] = 0;

   408    }

   409    u32_to_u8_iterator(BaseIterator b) : m_position(b), m_current(4)

   410    {

   411       m_values[0] = 0;

   412       m_values[1] = 0;

   413       m_values[2] = 0;

   414       m_values[3] = 0;

   415       m_values[4] = 0;

   416    }

   417 private:

   418 

   419    void extract_current()const

   420    {

   421       boost::uint32_t c = *m_position;

   422       if(c > 0x10FFFFu)

   423          detail::invalid_utf32_code_point(c);

   424       if(c < 0x80u)

   425       {

   426          m_values[0] = static_cast<unsigned char>(c);

   427          m_values[1] = static_cast<unsigned char>(0u);

   428          m_values[2] = static_cast<unsigned char>(0u);

   429          m_values[3] = static_cast<unsigned char>(0u);

   430       }

   431       else if(c < 0x800u)

   432       {

   433          m_values[0] = static_cast<unsigned char>(0xC0u + (c >> 6));

   434          m_values[1] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

   435          m_values[2] = static_cast<unsigned char>(0u);

   436          m_values[3] = static_cast<unsigned char>(0u);

   437       }

   438       else if(c < 0x10000u)

   439       {

   440          m_values[0] = static_cast<unsigned char>(0xE0u + (c >> 12));

   441          m_values[1] = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));

   442          m_values[2] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

   443          m_values[3] = static_cast<unsigned char>(0u);

   444       }

   445       else

   446       {

   447          m_values[0] = static_cast<unsigned char>(0xF0u + (c >> 18));

   448          m_values[1] = static_cast<unsigned char>(0x80u + ((c >> 12) & 0x3Fu));

   449          m_values[2] = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));

   450          m_values[3] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

   451       }

   452       m_current= 0;

   453    }

   454    BaseIterator m_position;

   455    mutable U8Type m_values[5];

   456    mutable unsigned m_current;

   457 };

   458 

   459 template <class BaseIterator, class U32Type = ::boost::uint32_t>

   460 class u8_to_u32_iterator

   461    : public boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>

   462 {

   463    typedef boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;

   464    // special values for pending iterator reads:

   465    BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);

   466 

   467 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

   468    typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

   469 

   470    BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 8);

   471    BOOST_STATIC_ASSERT(sizeof(U32Type)*CHAR_BIT == 32);

   472 #endif

   473 

   474 public:

   475    typename base_type::reference

   476       dereference()const

   477    {

   478       if(m_value == pending_read)

   479          extract_current();

   480       return m_value;

   481    }

   482    bool equal(const u8_to_u32_iterator& that)const

   483    {

   484       return m_position == that.m_position;

   485    }

   486    void increment()

   487    {

   488       // skip high surrogate first if there is one:

   489       unsigned c = detail::utf8_byte_count(*m_position);

   490       std::advance(m_position, c);

   491       m_value = pending_read;

   492    }

   493    void decrement()

   494    {

   495       // Keep backtracking until we don't have a trailing character:

   496       unsigned count = 0;

   497       while((*--m_position & 0xC0u) == 0x80u) ++count;

   498       // now check that the sequence was valid:

   499       if(count != detail::utf8_trailing_byte_count(*m_position))

   500          invalid_sequnce();

   501       m_value = pending_read;

   502    }

   503    BaseIterator base()const

   504    {

   505       return m_position;

   506    }

   507    // construct:

   508    u8_to_u32_iterator() : m_position()

   509    {

   510       m_value = pending_read;

   511    }

   512    u8_to_u32_iterator(BaseIterator b) : m_position(b)

   513    {

   514       m_value = pending_read;

   515    }

   516 private:

   517    static void invalid_sequnce()

   518    {

   519       std::out_of_range e("Invalid UTF-8 sequence encountered while trying to encode UTF-32 character");

   520       boost::throw_exception(e);

   521    }

   522    void extract_current()const

   523    {

   524       m_value = static_cast<U32Type>(static_cast< ::boost::uint8_t>(*m_position));

   525       // we must not have a continuation character:

   526       if((m_value & 0xC0u) == 0x80u)

   527          invalid_sequnce();

   528       // see how many extra byts we have:

   529       unsigned extra = detail::utf8_trailing_byte_count(*m_position);

   530       // extract the extra bits, 6 from each extra byte:

   531       BaseIterator next(m_position);

   532       for(unsigned c = 0; c < extra; ++c)

   533       {

   534          ++next;

   535          m_value <<= 6;

   536          m_value += static_cast<boost::uint8_t>(*next) & 0x3Fu;

   537       }

   538       // we now need to remove a few of the leftmost bits, but how many depends

   539       // upon how many extra bytes we've extracted:

   540       static const boost::uint32_t masks[4] = 

   541       {

   542          0x7Fu,

   543          0x7FFu,

   544          0xFFFFu,

   545          0x1FFFFFu,

   546       };

   547       m_value &= masks[extra];

   548       // check the result:

   549       if(m_value > static_cast<U32Type>(0x10FFFFu))

   550          invalid_sequnce();

   551    }

   552    BaseIterator m_position;

   553    mutable U32Type m_value;

   554 };

   555 

   556 template <class BaseIterator>

   557 class utf16_output_iterator

   558 {

   559 public:

   560    typedef void                                   difference_type;

   561    typedef void                                   value_type;

   562    typedef boost::uint32_t*                       pointer;

   563    typedef boost::uint32_t&                       reference;

   564    typedef std::output_iterator_tag               iterator_category;

   565 

   566    utf16_output_iterator(const BaseIterator& b)

   567       : m_position(b){}

   568    utf16_output_iterator(const utf16_output_iterator& that)

   569       : m_position(that.m_position){}

   570    utf16_output_iterator& operator=(const utf16_output_iterator& that)

   571    {

   572       m_position = that.m_position;

   573       return *this;

   574    }

   575    const utf16_output_iterator& operator*()const

   576    {

   577       return *this;

   578    }

   579    void operator=(boost::uint32_t val)const

   580    {

   581       push(val);

   582    }

   583    utf16_output_iterator& operator++()

   584    {

   585       return *this;

   586    }

   587    utf16_output_iterator& operator++(int)

   588    {

   589       return *this;

   590    }

   591    BaseIterator base()const

   592    {

   593       return m_position;

   594    }

   595 private:

   596    void push(boost::uint32_t v)const

   597    {

   598       if(v >= 0x10000u)

   599       {

   600          // begin by checking for a code point out of range:

   601          if(v > 0x10FFFFu)

   602             detail::invalid_utf32_code_point(v);

   603          // split into two surrogates:

   604          *m_position++ = static_cast<boost::uint16_t>(v >> 10) + detail::high_surrogate_base;

   605          *m_position++ = static_cast<boost::uint16_t>(v & detail::ten_bit_mask) + detail::low_surrogate_base;

   606       }

   607       else

   608       {

   609          // 16-bit code point:

   610          // value must not be a surrogate:

   611          if(detail::is_surrogate(v))

   612             detail::invalid_utf32_code_point(v);

   613          *m_position++ = static_cast<boost::uint16_t>(v);

   614       }

   615    }

   616    mutable BaseIterator m_position;

   617 };

   618 

   619 template <class BaseIterator>

   620 class utf8_output_iterator

   621 {

   622 public:

   623    typedef void                                   difference_type;

   624    typedef void                                   value_type;

   625    typedef boost::uint32_t*                       pointer;

   626    typedef boost::uint32_t&                       reference;

   627    typedef std::output_iterator_tag               iterator_category;

   628 

   629    utf8_output_iterator(const BaseIterator& b)

   630       : m_position(b){}

   631    utf8_output_iterator(const utf8_output_iterator& that)

   632       : m_position(that.m_position){}

   633    utf8_output_iterator& operator=(const utf8_output_iterator& that)

   634    {

   635       m_position = that.m_position;

   636       return *this;

   637    }

   638    const utf8_output_iterator& operator*()const

   639    {

   640       return *this;

   641    }

   642    void operator=(boost::uint32_t val)const

   643    {

   644       push(val);

   645    }

   646    utf8_output_iterator& operator++()

   647    {

   648       return *this;

   649    }

   650    utf8_output_iterator& operator++(int)

   651    {

   652       return *this;

   653    }

   654    BaseIterator base()const

   655    {

   656       return m_position;

   657    }

   658 private:

   659    void push(boost::uint32_t c)const

   660    {

   661       if(c > 0x10FFFFu)

   662          detail::invalid_utf32_code_point(c);

   663       if(c < 0x80u)

   664       {

   665          *m_position++ = static_cast<unsigned char>(c);

   666       }

   667       else if(c < 0x800u)

   668       {

   669          *m_position++ = static_cast<unsigned char>(0xC0u + (c >> 6));

   670          *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

   671       }

   672       else if(c < 0x10000u)

   673       {

   674          *m_position++ = static_cast<unsigned char>(0xE0u + (c >> 12));

   675          *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));

   676          *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

   677       }

   678       else

   679       {

   680          *m_position++ = static_cast<unsigned char>(0xF0u + (c >> 18));

   681          *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 12) & 0x3Fu));

   682          *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));

   683          *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

   684       }

   685    }

   686    mutable BaseIterator m_position;

   687 };

   688 

   689 } // namespace boost

   690 

   691 #endif // BOOST_REGEX_UNICODE_ITERATOR_HPP

   692