l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.8/include/ext/codecvt_specializations.h

   1 // Locale support (codecvt) -*- C++ -*-
   2
   3 // Copyright (C) 2000-2013 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 //
  26 // ISO C++ 14882: 22.2.1.5 Template class codecvt
  27 //
  28
  29 // Written by Benjamin Kosnik <bkoz@redhat.com>
  30
  31 /** @file ext/codecvt_specializations.h
  32  *  This file is a GNU extension to the Standard C++ Library.
  33  */
  34
  35 #ifndef _EXT_CODECVT_SPECIALIZATIONS_H
  36 #define _EXT_CODECVT_SPECIALIZATIONS_H 1
  37
  38 #include <bits/c++config.h>
  39 #include <locale>
  40 #include <iconv.h>
  41
  42 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
  43 {
  44 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  45
  46   /// Extension to use iconv for dealing with character encodings.
  47   // This includes conversions and comparisons between various character
  48   // sets.  This object encapsulates data that may need to be shared between
  49   // char_traits, codecvt and ctype.
  50   class encoding_state
  51   {
  52   public:
  53     // Types:
  54     // NB: A conversion descriptor subsumes and enhances the
  55     // functionality of a simple state type such as mbstate_t.
  56     typedef iconv_t     descriptor_type;
  57
  58   protected:
  59     // Name of internal character set encoding.
  60     std::string         _M_int_enc;
  61
  62     // Name of external character set encoding.
  63     std::string         _M_ext_enc;
  64
  65     // Conversion descriptor between external encoding to internal encoding.
  66     descriptor_type     _M_in_desc;
  67
  68     // Conversion descriptor between internal encoding to external encoding.
  69     descriptor_type     _M_out_desc;
  70
  71     // The byte-order marker for the external encoding, if necessary.
  72     int                 _M_ext_bom;
  73
  74     // The byte-order marker for the internal encoding, if necessary.
  75     int                 _M_int_bom;
  76
  77     // Number of external bytes needed to construct one complete
  78     // character in the internal encoding.
  79     // NB: -1 indicates variable, or stateful, encodings.
  80     int                 _M_bytes;
  81
  82   public:
  83     explicit
  84     encoding_state()
  85     : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0), _M_bytes(0)
  86     { }
  87
  88     explicit
  89     encoding_state(const char* __int, const char* __ext,
  90                    int __ibom = 0, int __ebom = 0, int __bytes = 1)
  91     : _M_int_enc(__int), _M_ext_enc(__ext), _M_in_desc(0), _M_out_desc(0),
  92       _M_ext_bom(__ebom), _M_int_bom(__ibom), _M_bytes(__bytes)
  93     { init(); }
  94
  95     // 21.1.2 traits typedefs
  96     // p4
  97     // typedef STATE_T state_type
  98     // requires: state_type shall meet the requirements of
  99     // CopyConstructible types (20.1.3)
 100     // NB: This does not preserve the actual state of the conversion
 101     // descriptor member, but it does duplicate the encoding
 102     // information.
 103     encoding_state(const encoding_state& __obj) : _M_in_desc(0), _M_out_desc(0)
 104     { construct(__obj); }
 105
 106     // Need assignment operator as well.
 107     encoding_state&
 108     operator=(const encoding_state& __obj)
 109     {
 110       construct(__obj);
 111       return *this;
 112     }
 113
 114     ~encoding_state()
 115     { destroy(); }
 116
 117     bool
 118     good() const throw()
 119     {
 120       const descriptor_type __err = (iconv_t)(-1);
 121       bool __test = _M_in_desc && _M_in_desc != __err;
 122       __test &=  _M_out_desc && _M_out_desc != __err;
 123       return __test;
 124     }
 125
 126     int
 127     character_ratio() const
 128     { return _M_bytes; }
 129
 130     const std::string
 131     internal_encoding() const
 132     { return _M_int_enc; }
 133
 134     int
 135     internal_bom() const
 136     { return _M_int_bom; }
 137
 138     const std::string
 139     external_encoding() const
 140     { return _M_ext_enc; }
 141
 142     int
 143     external_bom() const
 144     { return _M_ext_bom; }
 145
 146     const descriptor_type&
 147     in_descriptor() const
 148     { return _M_in_desc; }
 149
 150     const descriptor_type&
 151     out_descriptor() const
 152     { return _M_out_desc; }
 153
 154   protected:
 155     void
 156     init()
 157     {
 158       const descriptor_type __err = (iconv_t)(-1);
 159       const bool __have_encodings = _M_int_enc.size() && _M_ext_enc.size();
 160       if (!_M_in_desc && __have_encodings)
 161         {
 162           _M_in_desc = iconv_open(_M_int_enc.c_str(), _M_ext_enc.c_str());
 163           if (_M_in_desc == __err)
 164             std::__throw_runtime_error(__N("encoding_state::_M_init "
 165                                     "creating iconv input descriptor failed"));
 166         }
 167       if (!_M_out_desc && __have_encodings)
 168         {
 169           _M_out_desc = iconv_open(_M_ext_enc.c_str(), _M_int_enc.c_str());
 170           if (_M_out_desc == __err)
 171             std::__throw_runtime_error(__N("encoding_state::_M_init "
 172                                   "creating iconv output descriptor failed"));
 173         }
 174     }
 175
 176     void
 177     construct(const encoding_state& __obj)
 178     {
 179       destroy();
 180       _M_int_enc = __obj._M_int_enc;
 181       _M_ext_enc = __obj._M_ext_enc;
 182       _M_ext_bom = __obj._M_ext_bom;
 183       _M_int_bom = __obj._M_int_bom;
 184       _M_bytes = __obj._M_bytes;
 185       init();
 186     }
 187
 188     void
 189     destroy() throw()
 190     {
 191       const descriptor_type __err = (iconv_t)(-1);
 192       if (_M_in_desc && _M_in_desc != __err)
 193         {
 194           iconv_close(_M_in_desc);
 195           _M_in_desc = 0;
 196         }
 197       if (_M_out_desc && _M_out_desc != __err)
 198         {
 199           iconv_close(_M_out_desc);
 200           _M_out_desc = 0;
 201         }
 202     }
 203   };
 204
 205   /// encoding_char_traits
 206   // Custom traits type with encoding_state for the state type, and the
 207   // associated fpos<encoding_state> for the position type, all other
 208   // bits equivalent to the required char_traits instantiations.
 209   template<typename _CharT>
 210     struct encoding_char_traits : public std::char_traits<_CharT>
 211     {
 212       typedef encoding_state                            state_type;
 213       typedef typename std::fpos<state_type>            pos_type;
 214     };
 215
 216 _GLIBCXX_END_NAMESPACE_VERSION
 217 } // namespace
 218
 219
 220 namespace std _GLIBCXX_VISIBILITY(default)
 221 {
 222 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 223
 224   using __gnu_cxx::encoding_state;
 225
 226   /// codecvt<InternT, _ExternT, encoding_state> specialization.
 227   // This partial specialization takes advantage of iconv to provide
 228   // code conversions between a large number of character encodings.
 229   template<typename _InternT, typename _ExternT>
 230     class codecvt<_InternT, _ExternT, encoding_state>
 231     : public __codecvt_abstract_base<_InternT, _ExternT, encoding_state>
 232     {
 233     public:
 234       // Types:
 235       typedef codecvt_base::result                      result;
 236       typedef _InternT                                  intern_type;
 237       typedef _ExternT                                  extern_type;
 238       typedef __gnu_cxx::encoding_state                 state_type;
 239       typedef state_type::descriptor_type               descriptor_type;
 240
 241       // Data Members:
 242       static locale::id                 id;
 243
 244       explicit
 245       codecvt(size_t __refs = 0)
 246       : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
 247       { }
 248
 249       explicit
 250       codecvt(state_type& __enc, size_t __refs = 0)
 251       : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
 252       { }
 253
 254      protected:
 255       virtual
 256       ~codecvt() { }
 257
 258       virtual result
 259       do_out(state_type& __state, const intern_type* __from,
 260              const intern_type* __from_end, const intern_type*& __from_next,
 261              extern_type* __to, extern_type* __to_end,
 262              extern_type*& __to_next) const;
 263
 264       virtual result
 265       do_unshift(state_type& __state, extern_type* __to,
 266                  extern_type* __to_end, extern_type*& __to_next) const;
 267
 268       virtual result
 269       do_in(state_type& __state, const extern_type* __from,
 270             const extern_type* __from_end, const extern_type*& __from_next,
 271             intern_type* __to, intern_type* __to_end,
 272             intern_type*& __to_next) const;
 273
 274       virtual int
 275       do_encoding() const throw();
 276
 277       virtual bool
 278       do_always_noconv() const throw();
 279
 280       virtual int
 281       do_length(state_type&, const extern_type* __from,
 282                 const extern_type* __end, size_t __max) const;
 283
 284       virtual int
 285       do_max_length() const throw();
 286     };
 287
 288   template<typename _InternT, typename _ExternT>
 289     locale::id
 290     codecvt<_InternT, _ExternT, encoding_state>::id;
 291
 292   // This adaptor works around the signature problems of the second
 293   // argument to iconv():  SUSv2 and others use 'const char**', but glibc 2.2
 294   // uses 'char**', which matches the POSIX 1003.1-2001 standard.
 295   // Using this adaptor, g++ will do the work for us.
 296   template<typename _Tp>
 297     inline size_t
 298     __iconv_adaptor(size_t(*__func)(iconv_t, _Tp, size_t*, char**, size_t*),
 299                     iconv_t __cd, char** __inbuf, size_t* __inbytes,
 300                     char** __outbuf, size_t* __outbytes)
 301     { return __func(__cd, (_Tp)__inbuf, __inbytes, __outbuf, __outbytes); }
 302
 303   template<typename _InternT, typename _ExternT>
 304     codecvt_base::result
 305     codecvt<_InternT, _ExternT, encoding_state>::
 306     do_out(state_type& __state, const intern_type* __from,
 307            const intern_type* __from_end, const intern_type*& __from_next,
 308            extern_type* __to, extern_type* __to_end,
 309            extern_type*& __to_next) const
 310     {
 311       result __ret = codecvt_base::error;
 312       if (__state.good())
 313         {
 314           const descriptor_type& __desc = __state.out_descriptor();
 315           const size_t __fmultiple = sizeof(intern_type);
 316           size_t __fbytes = __fmultiple * (__from_end - __from);
 317           const size_t __tmultiple = sizeof(extern_type);
 318           size_t __tbytes = __tmultiple * (__to_end - __to);
 319
 320           // Argument list for iconv specifies a byte sequence. Thus,
 321           // all to/from arrays must be brutally casted to char*.
 322           char* __cto = reinterpret_cast<char*>(__to);
 323           char* __cfrom;
 324           size_t __conv;
 325
 326           // Some encodings need a byte order marker as the first item
 327           // in the byte stream, to designate endian-ness. The default
 328           // value for the byte order marker is NULL, so if this is
 329           // the case, it's not necessary and we can just go on our
 330           // merry way.
 331           int __int_bom = __state.internal_bom();
 332           if (__int_bom)
 333             {
 334               size_t __size = __from_end - __from;
 335               intern_type* __cfixed = static_cast<intern_type*>
 336                 (__builtin_alloca(sizeof(intern_type) * (__size + 1)));
 337               __cfixed[0] = static_cast<intern_type>(__int_bom);
 338               char_traits<intern_type>::copy(__cfixed + 1, __from, __size);
 339               __cfrom = reinterpret_cast<char*>(__cfixed);
 340               __conv = __iconv_adaptor(iconv, __desc, &__cfrom,
 341                                         &__fbytes, &__cto, &__tbytes);
 342             }
 343           else
 344             {
 345               intern_type* __cfixed = const_cast<intern_type*>(__from);
 346               __cfrom = reinterpret_cast<char*>(__cfixed);
 347               __conv = __iconv_adaptor(iconv, __desc, &__cfrom, &__fbytes,
 348                                        &__cto, &__tbytes);
 349             }
 350
 351           if (__conv != size_t(-1))
 352             {
 353               __from_next = reinterpret_cast<const intern_type*>(__cfrom);
 354               __to_next = reinterpret_cast<extern_type*>(__cto);
 355               __ret = codecvt_base::ok;
 356             }
 357           else
 358             {
 359               if (__fbytes < __fmultiple * (__from_end - __from))
 360                 {
 361                   __from_next = reinterpret_cast<const intern_type*>(__cfrom);
 362                   __to_next = reinterpret_cast<extern_type*>(__cto);
 363                   __ret = codecvt_base::partial;
 364                 }
 365               else
 366                 __ret = codecvt_base::error;
 367             }
 368         }
 369       return __ret;
 370     }
 371
 372   template<typename _InternT, typename _ExternT>
 373     codecvt_base::result
 374     codecvt<_InternT, _ExternT, encoding_state>::
 375     do_unshift(state_type& __state, extern_type* __to,
 376                extern_type* __to_end, extern_type*& __to_next) const
 377     {
 378       result __ret = codecvt_base::error;
 379       if (__state.good())
 380         {
 381           const descriptor_type& __desc = __state.in_descriptor();
 382           const size_t __tmultiple = sizeof(intern_type);
 383           size_t __tlen = __tmultiple * (__to_end - __to);
 384
 385           // Argument list for iconv specifies a byte sequence. Thus,
 386           // all to/from arrays must be brutally casted to char*.
 387           char* __cto = reinterpret_cast<char*>(__to);
 388           size_t __conv = __iconv_adaptor(iconv,__desc, 0, 0,
 389                                           &__cto, &__tlen);
 390
 391           if (__conv != size_t(-1))
 392             {
 393               __to_next = reinterpret_cast<extern_type*>(__cto);
 394               if (__tlen == __tmultiple * (__to_end - __to))
 395                 __ret = codecvt_base::noconv;
 396               else if (__tlen == 0)
 397                 __ret = codecvt_base::ok;
 398               else
 399                 __ret = codecvt_base::partial;
 400             }
 401           else
 402             __ret = codecvt_base::error;
 403         }
 404       return __ret;
 405     }
 406
 407   template<typename _InternT, typename _ExternT>
 408     codecvt_base::result
 409     codecvt<_InternT, _ExternT, encoding_state>::
 410     do_in(state_type& __state, const extern_type* __from,
 411           const extern_type* __from_end, const extern_type*& __from_next,
 412           intern_type* __to, intern_type* __to_end,
 413           intern_type*& __to_next) const
 414     {
 415       result __ret = codecvt_base::error;
 416       if (__state.good())
 417         {
 418           const descriptor_type& __desc = __state.in_descriptor();
 419           const size_t __fmultiple = sizeof(extern_type);
 420           size_t __flen = __fmultiple * (__from_end - __from);
 421           const size_t __tmultiple = sizeof(intern_type);
 422           size_t __tlen = __tmultiple * (__to_end - __to);
 423
 424           // Argument list for iconv specifies a byte sequence. Thus,
 425           // all to/from arrays must be brutally casted to char*.
 426           char* __cto = reinterpret_cast<char*>(__to);
 427           char* __cfrom;
 428           size_t __conv;
 429
 430           // Some encodings need a byte order marker as the first item
 431           // in the byte stream, to designate endian-ness. The default
 432           // value for the byte order marker is NULL, so if this is
 433           // the case, it's not necessary and we can just go on our
 434           // merry way.
 435           int __ext_bom = __state.external_bom();
 436           if (__ext_bom)
 437             {
 438               size_t __size = __from_end - __from;
 439               extern_type* __cfixed =  static_cast<extern_type*>
 440                 (__builtin_alloca(sizeof(extern_type) * (__size + 1)));
 441               __cfixed[0] = static_cast<extern_type>(__ext_bom);
 442               char_traits<extern_type>::copy(__cfixed + 1, __from, __size);
 443               __cfrom = reinterpret_cast<char*>(__cfixed);
 444               __conv = __iconv_adaptor(iconv, __desc, &__cfrom,
 445                                        &__flen, &__cto, &__tlen);
 446             }
 447           else
 448             {
 449               extern_type* __cfixed = const_cast<extern_type*>(__from);
 450               __cfrom = reinterpret_cast<char*>(__cfixed);
 451               __conv = __iconv_adaptor(iconv, __desc, &__cfrom,
 452                                        &__flen, &__cto, &__tlen);
 453             }
 454
 455
 456           if (__conv != size_t(-1))
 457             {
 458               __from_next = reinterpret_cast<const extern_type*>(__cfrom);
 459               __to_next = reinterpret_cast<intern_type*>(__cto);
 460               __ret = codecvt_base::ok;
 461             }
 462           else
 463             {
 464               if (__flen < static_cast<size_t>(__from_end - __from))
 465                 {
 466                   __from_next = reinterpret_cast<const extern_type*>(__cfrom);
 467                   __to_next = reinterpret_cast<intern_type*>(__cto);
 468                   __ret = codecvt_base::partial;
 469                 }
 470               else
 471                 __ret = codecvt_base::error;
 472             }
 473         }
 474       return __ret;
 475     }
 476
 477   template<typename _InternT, typename _ExternT>
 478     int
 479     codecvt<_InternT, _ExternT, encoding_state>::
 480     do_encoding() const throw()
 481     {
 482       int __ret = 0;
 483       if (sizeof(_ExternT) <= sizeof(_InternT))
 484         __ret = sizeof(_InternT) / sizeof(_ExternT);
 485       return __ret;
 486     }
 487
 488   template<typename _InternT, typename _ExternT>
 489     bool
 490     codecvt<_InternT, _ExternT, encoding_state>::
 491     do_always_noconv() const throw()
 492     { return false; }
 493
 494   template<typename _InternT, typename _ExternT>
 495     int
 496     codecvt<_InternT, _ExternT, encoding_state>::
 497     do_length(state_type&, const extern_type* __from,
 498               const extern_type* __end, size_t __max) const
 499     { return std::min(__max, static_cast<size_t>(__end - __from)); }
 500
 501   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 502   // 74.  Garbled text for codecvt::do_max_length
 503   template<typename _InternT, typename _ExternT>
 504     int
 505     codecvt<_InternT, _ExternT, encoding_state>::
 506     do_max_length() const throw()
 507     { return 1; }
 508
 509 _GLIBCXX_END_NAMESPACE_VERSION
 510 } // namespace
 511
 512 #endif