libstdc++-v3/config/locale/gnu/codecvt_members.cc

   1 // std::codecvt implementation details, GNU version -*- C++ -*-
   2
   3 // Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
   4 // Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // Under Section 7 of GPL version 3, you are granted additional
  18 // permissions described in the GCC Runtime Library Exception, version
  19 // 3.1, as published by the Free Software Foundation.
  20
  21 // You should have received a copy of the GNU General Public License and
  22 // a copy of the GCC Runtime Library Exception along with this program;
  23 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 // <http://www.gnu.org/licenses/>.
  25
  26 //
  27 // ISO C++ 14882: 22.2.1.5 - Template class codecvt
  28 //
  29
  30 // Written by Benjamin Kosnik <bkoz@redhat.com>
  31
  32 #include <locale>
  33 #include <cstdlib>  // For MB_CUR_MAX
  34 #include <climits>  // For MB_LEN_MAX
  35 #include <bits/c++locale_internal.h>
  36
  37 _GLIBCXX_BEGIN_NAMESPACE(std)
  38
  39   // Specializations.
  40 #ifdef _GLIBCXX_USE_WCHAR_T
  41   codecvt_base::result
  42   codecvt<wchar_t, char, mbstate_t>::
  43   do_out(state_type& __state, const intern_type* __from,
  44          const intern_type* __from_end, const intern_type*& __from_next,
  45          extern_type* __to, extern_type* __to_end,
  46          extern_type*& __to_next) const
  47   {
  48     result __ret = ok;
  49     state_type __tmp_state(__state);
  50
  51 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
  52     __c_locale __old = __uselocale(_M_c_locale_codecvt);
  53 #endif
  54
  55     // wcsnrtombs is *very* fast but stops if encounters NUL characters:
  56     // in case we fall back to wcrtomb and then continue, in a loop.
  57     // NB: wcsnrtombs is a GNU extension
  58     for (__from_next = __from, __to_next = __to;
  59          __from_next < __from_end && __to_next < __to_end
  60          && __ret == ok;)
  61       {
  62         const intern_type* __from_chunk_end = wmemchr(__from_next, L'\0',
  63                                                       __from_end - __from_next);
  64         if (!__from_chunk_end)
  65           __from_chunk_end = __from_end;
  66
  67         __from = __from_next;
  68         const size_t __conv = wcsnrtombs(__to_next, &__from_next,
  69                                          __from_chunk_end - __from_next,
  70                                          __to_end - __to_next, &__state);
  71         if (__conv == static_cast<size_t>(-1))
  72           {
  73             // In case of error, in order to stop at the exact place we
  74             // have to start again from the beginning with a series of
  75             // wcrtomb.
  76             for (; __from < __from_next; ++__from)
  77               __to_next += wcrtomb(__to_next, *__from, &__tmp_state);
  78             __state = __tmp_state;
  79             __ret = error;
  80           }
  81         else if (__from_next && __from_next < __from_chunk_end)
  82           {
  83             __to_next += __conv;
  84             __ret = partial;
  85           }
  86         else
  87           {
  88             __from_next = __from_chunk_end;
  89             __to_next += __conv;
  90           }
  91
  92         if (__from_next < __from_end && __ret == ok)
  93           {
  94             extern_type __buf[MB_LEN_MAX];
  95             __tmp_state = __state;
  96             const size_t __conv2 = wcrtomb(__buf, *__from_next, &__tmp_state);
  97             if (__conv2 > static_cast<size_t>(__to_end - __to_next))
  98               __ret = partial;
  99             else
 100               {
 101                 memcpy(__to_next, __buf, __conv2);
 102                 __state = __tmp_state;
 103                 __to_next += __conv2;
 104                 ++__from_next;
 105               }
 106           }
 107       }
 108
 109 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 110     __uselocale(__old);
 111 #endif
 112
 113     return __ret;
 114   }
 115
 116   codecvt_base::result
 117   codecvt<wchar_t, char, mbstate_t>::
 118   do_in(state_type& __state, const extern_type* __from,
 119         const extern_type* __from_end, const extern_type*& __from_next,
 120         intern_type* __to, intern_type* __to_end,
 121         intern_type*& __to_next) const
 122   {
 123     result __ret = ok;
 124     state_type __tmp_state(__state);
 125
 126 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 127     __c_locale __old = __uselocale(_M_c_locale_codecvt);
 128 #endif
 129
 130     // mbsnrtowcs is *very* fast but stops if encounters NUL characters:
 131     // in case we store a L'\0' and then continue, in a loop.
 132     // NB: mbsnrtowcs is a GNU extension
 133     for (__from_next = __from, __to_next = __to;
 134          __from_next < __from_end && __to_next < __to_end
 135          && __ret == ok;)
 136       {
 137         const extern_type* __from_chunk_end;
 138         __from_chunk_end = static_cast<const extern_type*>(memchr(__from_next, '\0',
 139                                                                   __from_end
 140                                                                   - __from_next));
 141         if (!__from_chunk_end)
 142           __from_chunk_end = __from_end;
 143
 144         __from = __from_next;
 145         size_t __conv = mbsnrtowcs(__to_next, &__from_next,
 146                                    __from_chunk_end - __from_next,
 147                                    __to_end - __to_next, &__state);
 148         if (__conv == static_cast<size_t>(-1))
 149           {
 150             // In case of error, in order to stop at the exact place we
 151             // have to start again from the beginning with a series of
 152             // mbrtowc.
 153             for (;; ++__to_next, __from += __conv)
 154               {
 155                 __conv = mbrtowc(__to_next, __from, __from_end - __from,
 156                                  &__tmp_state);
 157                 if (__conv == static_cast<size_t>(-1)
 158                     || __conv == static_cast<size_t>(-2))
 159                   break;
 160               }
 161             __from_next = __from;
 162             __state = __tmp_state;
 163             __ret = error;
 164           }
 165         else if (__from_next && __from_next < __from_chunk_end)
 166           {
 167             // It is unclear what to return in this case (see DR 382).
 168             __to_next += __conv;
 169             __ret = partial;
 170           }
 171         else
 172           {
 173             __from_next = __from_chunk_end;
 174             __to_next += __conv;
 175           }
 176
 177         if (__from_next < __from_end && __ret == ok)
 178           {
 179             if (__to_next < __to_end)
 180               {
 181                 // XXX Probably wrong for stateful encodings
 182                 __tmp_state = __state;
 183                 ++__from_next;
 184                 *__to_next++ = L'\0';
 185               }
 186             else
 187               __ret = partial;
 188           }
 189       }
 190
 191 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 192     __uselocale(__old);
 193 #endif
 194
 195     return __ret;
 196   }
 197
 198   int
 199   codecvt<wchar_t, char, mbstate_t>::
 200   do_encoding() const throw()
 201   {
 202     // XXX This implementation assumes that the encoding is
 203     // stateless and is either single-byte or variable-width.
 204     int __ret = 0;
 205 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 206     __c_locale __old = __uselocale(_M_c_locale_codecvt);
 207 #endif
 208     if (MB_CUR_MAX == 1)
 209       __ret = 1;
 210 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 211     __uselocale(__old);
 212 #endif
 213     return __ret;
 214   }
 215
 216   int
 217   codecvt<wchar_t, char, mbstate_t>::
 218   do_max_length() const throw()
 219   {
 220 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 221     __c_locale __old = __uselocale(_M_c_locale_codecvt);
 222 #endif
 223     // XXX Probably wrong for stateful encodings.
 224     int __ret = MB_CUR_MAX;
 225 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 226     __uselocale(__old);
 227 #endif
 228     return __ret;
 229   }
 230
 231   int
 232   codecvt<wchar_t, char, mbstate_t>::
 233   do_length(state_type& __state, const extern_type* __from,
 234             const extern_type* __end, size_t __max) const
 235   {
 236     int __ret = 0;
 237     state_type __tmp_state(__state);
 238
 239 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 240     __c_locale __old = __uselocale(_M_c_locale_codecvt);
 241 #endif
 242
 243     // mbsnrtowcs is *very* fast but stops if encounters NUL characters:
 244     // in case we advance past it and then continue, in a loop.
 245     // NB: mbsnrtowcs is a GNU extension
 246
 247     // A dummy internal buffer is needed in order for mbsnrtocws to consider
 248     // its fourth parameter (it wouldn't with NULL as first parameter).
 249     wchar_t* __to = static_cast<wchar_t*>(__builtin_alloca(sizeof(wchar_t)
 250                                                            * __max));
 251     while (__from < __end && __max)
 252       {
 253         const extern_type* __from_chunk_end;
 254         __from_chunk_end = static_cast<const extern_type*>(memchr(__from, '\0',
 255                                                                   __end
 256                                                                   - __from));
 257         if (!__from_chunk_end)
 258           __from_chunk_end = __end;
 259
 260         const extern_type* __tmp_from = __from;
 261         size_t __conv = mbsnrtowcs(__to, &__from,
 262                                    __from_chunk_end - __from,
 263                                    __max, &__state);
 264         if (__conv == static_cast<size_t>(-1))
 265           {
 266             // In case of error, in order to stop at the exact place we
 267             // have to start again from the beginning with a series of
 268             // mbrtowc.
 269             for (__from = __tmp_from;; __from += __conv)
 270               {
 271                 __conv = mbrtowc(0, __from, __end - __from,
 272                                  &__tmp_state);
 273                 if (__conv == static_cast<size_t>(-1)
 274                     || __conv == static_cast<size_t>(-2))
 275                   break;
 276               }
 277             __state = __tmp_state;
 278             __ret += __from - __tmp_from;
 279             break;
 280           }
 281         if (!__from)
 282           __from = __from_chunk_end;
 283
 284         __ret += __from - __tmp_from;
 285         __max -= __conv;
 286
 287         if (__from < __end && __max)
 288           {
 289             // XXX Probably wrong for stateful encodings
 290             __tmp_state = __state;
 291             ++__from;
 292             ++__ret;
 293             --__max;
 294           }
 295       }
 296
 297 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
 298     __uselocale(__old);
 299 #endif
 300
 301     return __ret;
 302   }
 303 #endif
 304
 305 _GLIBCXX_END_NAMESPACE