1 // Locale support (codecvt) -*- C++ -*-
3 // Copyright (C) 2000-2014 Free Software Foundation, Inc.
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)
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.
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.
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/>.
26 // ISO C++ 14882: 22.2.1.5 Template class codecvt
29 // Written by Benjamin Kosnik <bkoz@redhat.com>
31 /** @file ext/codecvt_specializations.h
32 * This file is a GNU extension to the Standard C++ Library.
35 #ifndef _EXT_CODECVT_SPECIALIZATIONS_H
36 #define _EXT_CODECVT_SPECIALIZATIONS_H 1
38 #include <bits/c++config.h>
42 namespace __gnu_cxx
_GLIBCXX_VISIBILITY(default)
44 _GLIBCXX_BEGIN_NAMESPACE_VERSION
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.
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
;
59 // Name of internal character set encoding.
60 std::string _M_int_enc
;
62 // Name of external character set encoding.
63 std::string _M_ext_enc
;
65 // Conversion descriptor between external encoding to internal encoding.
66 descriptor_type _M_in_desc
;
68 // Conversion descriptor between internal encoding to external encoding.
69 descriptor_type _M_out_desc
;
71 // The byte-order marker for the external encoding, if necessary.
74 // The byte-order marker for the internal encoding, if necessary.
77 // Number of external bytes needed to construct one complete
78 // character in the internal encoding.
79 // NB: -1 indicates variable, or stateful, encodings.
85 : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0), _M_bytes(0)
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
)
95 // 21.1.2 traits typedefs
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
103 encoding_state(const encoding_state
& __obj
) : _M_in_desc(0), _M_out_desc(0)
104 { construct(__obj
); }
106 // Need assignment operator as well.
108 operator=(const encoding_state
& __obj
)
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
;
127 character_ratio() const
131 internal_encoding() const
132 { return _M_int_enc
; }
136 { return _M_int_bom
; }
139 external_encoding() const
140 { return _M_ext_enc
; }
144 { return _M_ext_bom
; }
146 const descriptor_type
&
147 in_descriptor() const
148 { return _M_in_desc
; }
150 const descriptor_type
&
151 out_descriptor() const
152 { return _M_out_desc
; }
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
)
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"));
167 if (!_M_out_desc
&& __have_encodings
)
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"));
177 construct(const encoding_state
& __obj
)
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
;
191 const descriptor_type __err
= (iconv_t
)(-1);
192 if (_M_in_desc
&& _M_in_desc
!= __err
)
194 iconv_close(_M_in_desc
);
197 if (_M_out_desc
&& _M_out_desc
!= __err
)
199 iconv_close(_M_out_desc
);
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
>
212 typedef encoding_state state_type
;
213 typedef typename
std::fpos
<state_type
> pos_type
;
216 _GLIBCXX_END_NAMESPACE_VERSION
220 namespace std
_GLIBCXX_VISIBILITY(default)
222 _GLIBCXX_BEGIN_NAMESPACE_VERSION
224 using __gnu_cxx::encoding_state
;
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
>
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
;
242 static locale::id id
;
245 codecvt(size_t __refs
= 0)
246 : __codecvt_abstract_base
<intern_type
, extern_type
, state_type
>(__refs
)
250 codecvt(state_type
& __enc
, size_t __refs
= 0)
251 : __codecvt_abstract_base
<intern_type
, extern_type
, state_type
>(__refs
)
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;
265 do_unshift(state_type
& __state
, extern_type
* __to
,
266 extern_type
* __to_end
, extern_type
*& __to_next
) const;
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;
275 do_encoding() const throw();
278 do_always_noconv() const throw();
281 do_length(state_type
&, const extern_type
* __from
,
282 const extern_type
* __end
, size_t __max
) const;
285 do_max_length() const throw();
288 template<typename _InternT
, typename _ExternT
>
290 codecvt
<_InternT
, _ExternT
, encoding_state
>::id
;
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
>
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
); }
303 template<typename _InternT
, typename _ExternT
>
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
311 result __ret
= codecvt_base::error
;
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
);
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
);
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
331 int __int_bom
= __state
.internal_bom();
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
);
345 intern_type
* __cfixed
= const_cast<intern_type
*>(__from
);
346 __cfrom
= reinterpret_cast<char*>(__cfixed
);
347 __conv
= __iconv_adaptor(iconv
, __desc
, &__cfrom
, &__fbytes
,
351 if (__conv
!= size_t(-1))
353 __from_next
= reinterpret_cast<const intern_type
*>(__cfrom
);
354 __to_next
= reinterpret_cast<extern_type
*>(__cto
);
355 __ret
= codecvt_base::ok
;
359 if (__fbytes
< __fmultiple
* (__from_end
- __from
))
361 __from_next
= reinterpret_cast<const intern_type
*>(__cfrom
);
362 __to_next
= reinterpret_cast<extern_type
*>(__cto
);
363 __ret
= codecvt_base::partial
;
366 __ret
= codecvt_base::error
;
372 template<typename _InternT
, typename _ExternT
>
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
378 result __ret
= codecvt_base::error
;
381 const descriptor_type
& __desc
= __state
.in_descriptor();
382 const size_t __tmultiple
= sizeof(intern_type
);
383 size_t __tlen
= __tmultiple
* (__to_end
- __to
);
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,
391 if (__conv
!= size_t(-1))
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
;
399 __ret
= codecvt_base::partial
;
402 __ret
= codecvt_base::error
;
407 template<typename _InternT
, typename _ExternT
>
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
415 result __ret
= codecvt_base::error
;
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
);
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
);
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
435 int __ext_bom
= __state
.external_bom();
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
);
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
);
456 if (__conv
!= size_t(-1))
458 __from_next
= reinterpret_cast<const extern_type
*>(__cfrom
);
459 __to_next
= reinterpret_cast<intern_type
*>(__cto
);
460 __ret
= codecvt_base::ok
;
464 if (__flen
< static_cast<size_t>(__from_end
- __from
))
466 __from_next
= reinterpret_cast<const extern_type
*>(__cfrom
);
467 __to_next
= reinterpret_cast<intern_type
*>(__cto
);
468 __ret
= codecvt_base::partial
;
471 __ret
= codecvt_base::error
;
477 template<typename _InternT
, typename _ExternT
>
479 codecvt
<_InternT
, _ExternT
, encoding_state
>::
480 do_encoding() const throw()
483 if (sizeof(_ExternT
) <= sizeof(_InternT
))
484 __ret
= sizeof(_InternT
) / sizeof(_ExternT
);
488 template<typename _InternT
, typename _ExternT
>
490 codecvt
<_InternT
, _ExternT
, encoding_state
>::
491 do_always_noconv() const throw()
494 template<typename _InternT
, typename _ExternT
>
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
)); }
501 // _GLIBCXX_RESOLVE_LIB_DEFECTS
502 // 74. Garbled text for codecvt::do_max_length
503 template<typename _InternT
, typename _ExternT
>
505 codecvt
<_InternT
, _ExternT
, encoding_state
>::
506 do_max_length() const throw()
509 _GLIBCXX_END_NAMESPACE_VERSION