libstdc++
charconv
Go to the documentation of this file.
1 // Primitive numeric conversions (to_chars and from_chars) -*- C++ -*-
2 
3 // Copyright (C) 2017-2021 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 /** @file include/charconv
26  * This is a Standard C++ Library header.
27  */
28 
29 #ifndef _GLIBCXX_CHARCONV
30 #define _GLIBCXX_CHARCONV 1
31 
32 #pragma GCC system_header
33 
34 // As an extension we support <charconv> in C++14, but this header should not
35 // be included by any other library headers in C++14 mode. This ensures that
36 // the names defined in this header are not added to namespace std unless a
37 // user explicitly includes <charconv> in C++14 code.
38 #if __cplusplus >= 201402L
39 
40 #include <type_traits>
41 #include <bit> // for __bit_width
42 #include <cctype> // for isdigit
43 #include <bits/charconv.h> // for __to_chars_len, __to_chars_10_impl
44 #include <bits/error_constants.h> // for std::errc
45 #include <ext/numeric_traits.h>
46 
47 #if _GLIBCXX_HAVE_USELOCALE
48 # define __cpp_lib_to_chars 201611L
49 #endif
50 
51 namespace std _GLIBCXX_VISIBILITY(default)
52 {
53 _GLIBCXX_BEGIN_NAMESPACE_VERSION
54 
55  /// Result type of std::to_chars
56  struct to_chars_result
57  {
58  char* ptr;
59  errc ec;
60 
61 #if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
62  friend bool
63  operator==(const to_chars_result&, const to_chars_result&) = default;
64 #endif
65  };
66 
67  /// Result type of std::from_chars
68  struct from_chars_result
69  {
70  const char* ptr;
71  errc ec;
72 
73 #if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
74  friend bool
75  operator==(const from_chars_result&, const from_chars_result&) = default;
76 #endif
77  };
78 
79 namespace __detail
80 {
81  template<typename _Tp>
82  using __integer_to_chars_result_type
83  = enable_if_t<__or_<__is_signed_integer<_Tp>,
84  __is_unsigned_integer<_Tp>,
85  is_same<char, remove_cv_t<_Tp>>>::value,
86  to_chars_result>;
87 
88  // Pick an unsigned type of suitable size. This is used to reduce the
89  // number of specializations of __to_chars_len, __to_chars etc. that
90  // get instantiated. For example, to_chars<char> and to_chars<short>
91  // and to_chars<unsigned> will all use the same code, and so will
92  // to_chars<long> when sizeof(int) == sizeof(long).
93  template<typename _Tp>
94  struct __to_chars_unsigned_type : __make_unsigned_selector_base
95  {
96  using _UInts = _List<unsigned int, unsigned long, unsigned long long
97 #if _GLIBCXX_USE_INT128
98  , unsigned __int128
99 #endif
100  >;
101  using type = typename __select<sizeof(_Tp), _UInts>::__type;
102  };
103 
104  template<typename _Tp>
105  using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;
106 
107  // Generic implementation for arbitrary bases.
108  // Defined in <bits/charconv.h>.
109  template<typename _Tp>
110  constexpr unsigned
111  __to_chars_len(_Tp __value, int __base /* = 10 */) noexcept;
112 
113  template<typename _Tp>
114  constexpr unsigned
115  __to_chars_len_2(_Tp __value) noexcept
116  { return std::__bit_width(__value); }
117 
118  // Generic implementation for arbitrary bases.
119  template<typename _Tp>
120  to_chars_result
121  __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
122  {
123  static_assert(is_integral<_Tp>::value, "implementation bug");
124  static_assert(is_unsigned<_Tp>::value, "implementation bug");
125 
126  to_chars_result __res;
127 
128  const unsigned __len = __to_chars_len(__val, __base);
129 
130  if (__builtin_expect((__last - __first) < __len, 0))
131  {
132  __res.ptr = __last;
133  __res.ec = errc::value_too_large;
134  return __res;
135  }
136 
137  unsigned __pos = __len - 1;
138 
139  static constexpr char __digits[] = {
140  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
141  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
142  'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
143  'u', 'v', 'w', 'x', 'y', 'z'
144  };
145 
146  while (__val >= (unsigned)__base)
147  {
148  auto const __quo = __val / __base;
149  auto const __rem = __val % __base;
150  __first[__pos--] = __digits[__rem];
151  __val = __quo;
152  }
153  *__first = __digits[__val];
154 
155  __res.ptr = __first + __len;
156  __res.ec = {};
157  return __res;
158  }
159 
160  template<typename _Tp>
161  __integer_to_chars_result_type<_Tp>
162  __to_chars_16(char* __first, char* __last, _Tp __val) noexcept
163  {
164  static_assert(is_integral<_Tp>::value, "implementation bug");
165  static_assert(is_unsigned<_Tp>::value, "implementation bug");
166 
167  to_chars_result __res;
168 
169  const unsigned __len = (__to_chars_len_2(__val) + 3) / 4;
170 
171  if (__builtin_expect((__last - __first) < __len, 0))
172  {
173  __res.ptr = __last;
174  __res.ec = errc::value_too_large;
175  return __res;
176  }
177 
178  static constexpr char __digits[] = {
179  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
180  'a', 'b', 'c', 'd', 'e', 'f'
181  };
182  unsigned __pos = __len - 1;
183  while (__val >= 0x100)
184  {
185  auto __num = __val & 0xF;
186  __val >>= 4;
187  __first[__pos] = __digits[__num];
188  __num = __val & 0xF;
189  __val >>= 4;
190  __first[__pos - 1] = __digits[__num];
191  __pos -= 2;
192  }
193  if (__val >= 0x10)
194  {
195  const auto __num = __val & 0xF;
196  __val >>= 4;
197  __first[1] = __digits[__num];
198  __first[0] = __digits[__val];
199  }
200  else
201  __first[0] = __digits[__val];
202  __res.ptr = __first + __len;
203  __res.ec = {};
204  return __res;
205  }
206 
207  template<typename _Tp>
208  inline __integer_to_chars_result_type<_Tp>
209  __to_chars_10(char* __first, char* __last, _Tp __val) noexcept
210  {
211  static_assert(is_integral<_Tp>::value, "implementation bug");
212  static_assert(is_unsigned<_Tp>::value, "implementation bug");
213 
214  to_chars_result __res;
215 
216  const unsigned __len = __to_chars_len(__val, 10);
217 
218  if (__builtin_expect((__last - __first) < __len, 0))
219  {
220  __res.ptr = __last;
221  __res.ec = errc::value_too_large;
222  return __res;
223  }
224 
225  __detail::__to_chars_10_impl(__first, __len, __val);
226  __res.ptr = __first + __len;
227  __res.ec = {};
228  return __res;
229  }
230 
231  template<typename _Tp>
232  __integer_to_chars_result_type<_Tp>
233  __to_chars_8(char* __first, char* __last, _Tp __val) noexcept
234  {
235  static_assert(is_integral<_Tp>::value, "implementation bug");
236  static_assert(is_unsigned<_Tp>::value, "implementation bug");
237 
238  to_chars_result __res;
239  unsigned __len;
240 
241  if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Tp>::__digits <= 16)
242  {
243  __len = __val > 077777u ? 6u
244  : __val > 07777u ? 5u
245  : __val > 0777u ? 4u
246  : __val > 077u ? 3u
247  : __val > 07u ? 2u
248  : 1u;
249  }
250  else
251  __len = (__to_chars_len_2(__val) + 2) / 3;
252 
253  if (__builtin_expect((__last - __first) < __len, 0))
254  {
255  __res.ptr = __last;
256  __res.ec = errc::value_too_large;
257  return __res;
258  }
259 
260  unsigned __pos = __len - 1;
261  while (__val >= 0100)
262  {
263  auto __num = __val & 7;
264  __val >>= 3;
265  __first[__pos] = '0' + __num;
266  __num = __val & 7;
267  __val >>= 3;
268  __first[__pos - 1] = '0' + __num;
269  __pos -= 2;
270  }
271  if (__val >= 010)
272  {
273  auto const __num = __val & 7;
274  __val >>= 3;
275  __first[1] = '0' + __num;
276  __first[0] = '0' + __val;
277  }
278  else
279  __first[0] = '0' + __val;
280  __res.ptr = __first + __len;
281  __res.ec = {};
282  return __res;
283  }
284 
285  template<typename _Tp>
286  __integer_to_chars_result_type<_Tp>
287  __to_chars_2(char* __first, char* __last, _Tp __val) noexcept
288  {
289  static_assert(is_integral<_Tp>::value, "implementation bug");
290  static_assert(is_unsigned<_Tp>::value, "implementation bug");
291 
292  to_chars_result __res;
293 
294  const unsigned __len = __to_chars_len_2(__val);
295 
296  if (__builtin_expect((__last - __first) < __len, 0))
297  {
298  __res.ptr = __last;
299  __res.ec = errc::value_too_large;
300  return __res;
301  }
302 
303  unsigned __pos = __len - 1;
304 
305  while (__pos)
306  {
307  __first[__pos--] = '0' + (__val & 1);
308  __val >>= 1;
309  }
310  // First digit is always '1' because __to_chars_len_2 skips
311  // leading zero bits and std::to_chars handles zero values
312  // directly.
313  __first[0] = '1';
314 
315  __res.ptr = __first + __len;
316  __res.ec = {};
317  return __res;
318  }
319 
320 } // namespace __detail
321 
322  template<typename _Tp>
323  __detail::__integer_to_chars_result_type<_Tp>
324  __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
325  {
326  __glibcxx_assert(2 <= __base && __base <= 36);
327 
328  using _Up = __detail::__unsigned_least_t<_Tp>;
329  _Up __unsigned_val = __value;
330 
331  if (__first == __last) [[__unlikely__]]
332  return { __last, errc::value_too_large };
333 
334  if (__value == 0)
335  {
336  *__first = '0';
337  return { __first + 1, errc{} };
338  }
339 
340  if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
341  if (__value < 0)
342  {
343  if (__builtin_expect(__first != __last, 1))
344  *__first++ = '-';
345  __unsigned_val = _Up(~__value) + _Up(1);
346  }
347 
348  switch (__base)
349  {
350  case 16:
351  return __detail::__to_chars_16(__first, __last, __unsigned_val);
352  case 10:
353  return __detail::__to_chars_10(__first, __last, __unsigned_val);
354  case 8:
355  return __detail::__to_chars_8(__first, __last, __unsigned_val);
356  case 2:
357  return __detail::__to_chars_2(__first, __last, __unsigned_val);
358  default:
359  return __detail::__to_chars(__first, __last, __unsigned_val, __base);
360  }
361  }
362 
363 #define _GLIBCXX_TO_CHARS(T) \
364  inline to_chars_result \
365  to_chars(char* __first, char* __last, T __value, int __base = 10) \
366  { return std::__to_chars_i<T>(__first, __last, __value, __base); }
367 _GLIBCXX_TO_CHARS(char)
368 _GLIBCXX_TO_CHARS(signed char)
369 _GLIBCXX_TO_CHARS(unsigned char)
370 _GLIBCXX_TO_CHARS(signed short)
371 _GLIBCXX_TO_CHARS(unsigned short)
372 _GLIBCXX_TO_CHARS(signed int)
373 _GLIBCXX_TO_CHARS(unsigned int)
374 _GLIBCXX_TO_CHARS(signed long)
375 _GLIBCXX_TO_CHARS(unsigned long)
376 _GLIBCXX_TO_CHARS(signed long long)
377 _GLIBCXX_TO_CHARS(unsigned long long)
378 #if defined(__GLIBCXX_TYPE_INT_N_0)
379 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_0)
380 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_0)
381 #endif
382 #if defined(__GLIBCXX_TYPE_INT_N_1)
383 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_1)
384 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_1)
385 #endif
386 #if defined(__GLIBCXX_TYPE_INT_N_2)
387 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_2)
388 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_2)
389 #endif
390 #if defined(__GLIBCXX_TYPE_INT_N_3)
391 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_3)
392 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_3)
393 #endif
394 #undef _GLIBCXX_TO_CHARS
395 
396  // _GLIBCXX_RESOLVE_LIB_DEFECTS
397  // 3266. to_chars(bool) should be deleted
398  to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
399 
400 namespace __detail
401 {
402  template<typename _Tp>
403  bool
404  __raise_and_add(_Tp& __val, int __base, unsigned char __c)
405  {
406  if (__builtin_mul_overflow(__val, __base, &__val)
407  || __builtin_add_overflow(__val, __c, &__val))
408  return false;
409  return true;
410  }
411 
412  /// std::from_chars implementation for integers in base 2.
413  template<typename _Tp>
414  bool
415  __from_chars_binary(const char*& __first, const char* __last, _Tp& __val)
416  {
417  static_assert(is_integral<_Tp>::value, "implementation bug");
418  static_assert(is_unsigned<_Tp>::value, "implementation bug");
419 
420  const ptrdiff_t __len = __last - __first;
421  ptrdiff_t __i = 0;
422  while (__i < __len && __first[__i] == '0')
423  ++__i;
424  const ptrdiff_t __leading_zeroes = __i;
425 
426  while (__i < __len)
427  {
428  const unsigned char __c = (unsigned)__first[__i] - '0';
429  if (__c < 2)
430  __val = (__val << 1) | __c;
431  else
432  break;
433  __i++;
434  }
435  __first += __i;
436  return (__i - __leading_zeroes) <= __gnu_cxx::__int_traits<_Tp>::__digits;
437  }
438 
439  /// std::from_chars implementation for integers in bases 3 to 10.
440  template<typename _Tp>
441  bool
442  __from_chars_digit(const char*& __first, const char* __last, _Tp& __val,
443  int __base)
444  {
445  static_assert(is_integral<_Tp>::value, "implementation bug");
446  static_assert(is_unsigned<_Tp>::value, "implementation bug");
447 
448  auto __matches = [__base](char __c) {
449  return '0' <= __c && __c <= ('0' + (__base - 1));
450  };
451 
452  while (__first != __last)
453  {
454  const char __c = *__first;
455  if (__matches(__c))
456  {
457  if (!__raise_and_add(__val, __base, __c - '0'))
458  {
459  while (++__first != __last && __matches(*__first))
460  ;
461  return false;
462  }
463  __first++;
464  }
465  else
466  return true;
467  }
468  return true;
469  }
470 
471  constexpr unsigned char
472  __from_chars_alpha_to_num(char __c)
473  {
474  switch (__c)
475  {
476  case 'a':
477  case 'A':
478  return 10;
479  case 'b':
480  case 'B':
481  return 11;
482  case 'c':
483  case 'C':
484  return 12;
485  case 'd':
486  case 'D':
487  return 13;
488  case 'e':
489  case 'E':
490  return 14;
491  case 'f':
492  case 'F':
493  return 15;
494  case 'g':
495  case 'G':
496  return 16;
497  case 'h':
498  case 'H':
499  return 17;
500  case 'i':
501  case 'I':
502  return 18;
503  case 'j':
504  case 'J':
505  return 19;
506  case 'k':
507  case 'K':
508  return 20;
509  case 'l':
510  case 'L':
511  return 21;
512  case 'm':
513  case 'M':
514  return 22;
515  case 'n':
516  case 'N':
517  return 23;
518  case 'o':
519  case 'O':
520  return 24;
521  case 'p':
522  case 'P':
523  return 25;
524  case 'q':
525  case 'Q':
526  return 26;
527  case 'r':
528  case 'R':
529  return 27;
530  case 's':
531  case 'S':
532  return 28;
533  case 't':
534  case 'T':
535  return 29;
536  case 'u':
537  case 'U':
538  return 30;
539  case 'v':
540  case 'V':
541  return 31;
542  case 'w':
543  case 'W':
544  return 32;
545  case 'x':
546  case 'X':
547  return 33;
548  case 'y':
549  case 'Y':
550  return 34;
551  case 'z':
552  case 'Z':
553  return 35;
554  }
555  return __gnu_cxx::__int_traits<unsigned char>::__max;
556  }
557 
558  /// std::from_chars implementation for integers in bases 11 to 26.
559  template<typename _Tp>
560  bool
561  __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
562  int __base)
563  {
564  bool __valid = true;
565  while (__first != __last)
566  {
567  unsigned char __c = *__first;
568  if (std::isdigit(__c))
569  __c -= '0';
570  else
571  {
572  __c = __from_chars_alpha_to_num(__c);
573  if (__c >= __base)
574  break;
575  }
576 
577  if (__builtin_expect(__valid, 1))
578  __valid = __raise_and_add(__val, __base, __c);
579  __first++;
580  }
581  return __valid;
582  }
583 
584  template<typename _Tp>
585  using __integer_from_chars_result_type
586  = enable_if_t<__or_<__is_signed_integer<_Tp>,
587  __is_unsigned_integer<_Tp>,
588  is_same<char, remove_cv_t<_Tp>>>::value,
589  from_chars_result>;
590 
591 } // namespace __detail
592 
593  /// std::from_chars for integral types.
594  template<typename _Tp>
595  __detail::__integer_from_chars_result_type<_Tp>
596  from_chars(const char* __first, const char* __last, _Tp& __value,
597  int __base = 10)
598  {
599  __glibcxx_assert(2 <= __base && __base <= 36);
600 
601  from_chars_result __res{__first, {}};
602 
603  int __sign = 1;
604  if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
605  if (__first != __last && *__first == '-')
606  {
607  __sign = -1;
608  ++__first;
609  }
610 
611  using _Up = __detail::__unsigned_least_t<_Tp>;
612  _Up __val = 0;
613 
614  const auto __start = __first;
615  bool __valid;
616  if (__base == 2)
617  __valid = __detail::__from_chars_binary(__first, __last, __val);
618  else if (__base <= 10)
619  __valid = __detail::__from_chars_digit(__first, __last, __val, __base);
620  else
621  __valid = __detail::__from_chars_alnum(__first, __last, __val, __base);
622 
623  if (__builtin_expect(__first == __start, 0))
624  __res.ec = errc::invalid_argument;
625  else
626  {
627  __res.ptr = __first;
628  if (!__valid)
629  __res.ec = errc::result_out_of_range;
630  else
631  {
632  if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
633  {
634  _Tp __tmp;
635  if (__builtin_mul_overflow(__val, __sign, &__tmp))
636  __res.ec = errc::result_out_of_range;
637  else
638  __value = __tmp;
639  }
640  else
641  {
642  if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Up>::__max
643  > __gnu_cxx::__int_traits<_Tp>::__max)
644  {
645  if (__val > __gnu_cxx::__int_traits<_Tp>::__max)
646  __res.ec = errc::result_out_of_range;
647  else
648  __value = __val;
649  }
650  else
651  __value = __val;
652  }
653  }
654  }
655  return __res;
656  }
657 
658  /// floating-point format for primitive numerical conversion
659  enum class chars_format
660  {
661  scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
662  };
663 
664  constexpr chars_format
665  operator|(chars_format __lhs, chars_format __rhs) noexcept
666  { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }
667 
668  constexpr chars_format
669  operator&(chars_format __lhs, chars_format __rhs) noexcept
670  { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }
671 
672  constexpr chars_format
673  operator^(chars_format __lhs, chars_format __rhs) noexcept
674  { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }
675 
676  constexpr chars_format
677  operator~(chars_format __fmt) noexcept
678  { return (chars_format)~(unsigned)__fmt; }
679 
680  constexpr chars_format&
681  operator|=(chars_format& __lhs, chars_format __rhs) noexcept
682  { return __lhs = __lhs | __rhs; }
683 
684  constexpr chars_format&
685  operator&=(chars_format& __lhs, chars_format __rhs) noexcept
686  { return __lhs = __lhs & __rhs; }
687 
688  constexpr chars_format&
689  operator^=(chars_format& __lhs, chars_format __rhs) noexcept
690  { return __lhs = __lhs ^ __rhs; }
691 
692 #if _GLIBCXX_HAVE_USELOCALE
693  from_chars_result
694  from_chars(const char* __first, const char* __last, float& __value,
695  chars_format __fmt = chars_format::general) noexcept;
696 
697  from_chars_result
698  from_chars(const char* __first, const char* __last, double& __value,
699  chars_format __fmt = chars_format::general) noexcept;
700 
701  from_chars_result
702  from_chars(const char* __first, const char* __last, long double& __value,
703  chars_format __fmt = chars_format::general) noexcept;
704 #endif
705 
706 #if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
707  && __SIZE_WIDTH__ >= 32
708  // Floating-point std::to_chars
709 
710  // Overloads for float.
711  to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
712  to_chars_result to_chars(char* __first, char* __last, float __value,
713  chars_format __fmt) noexcept;
714  to_chars_result to_chars(char* __first, char* __last, float __value,
715  chars_format __fmt, int __precision) noexcept;
716 
717  // Overloads for double.
718  to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
719  to_chars_result to_chars(char* __first, char* __last, double __value,
720  chars_format __fmt) noexcept;
721  to_chars_result to_chars(char* __first, char* __last, double __value,
722  chars_format __fmt, int __precision) noexcept;
723 
724  // Overloads for long double.
725  to_chars_result to_chars(char* __first, char* __last, long double __value)
726  noexcept;
727  to_chars_result to_chars(char* __first, char* __last, long double __value,
728  chars_format __fmt) noexcept;
729  to_chars_result to_chars(char* __first, char* __last, long double __value,
730  chars_format __fmt, int __precision) noexcept;
731 #endif
732 
733 _GLIBCXX_END_NAMESPACE_VERSION
734 } // namespace std
735 #endif // C++14
736 #endif // _GLIBCXX_CHARCONV