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  else if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
340  if (__value < 0)
341  {
342  *__first++ = '-';
343  __unsigned_val = _Up(~__value) + _Up(1);
344  }
345 
346  switch (__base)
347  {
348  case 16:
349  return __detail::__to_chars_16(__first, __last, __unsigned_val);
350  case 10:
351  return __detail::__to_chars_10(__first, __last, __unsigned_val);
352  case 8:
353  return __detail::__to_chars_8(__first, __last, __unsigned_val);
354  case 2:
355  return __detail::__to_chars_2(__first, __last, __unsigned_val);
356  default:
357  return __detail::__to_chars(__first, __last, __unsigned_val, __base);
358  }
359  }
360 
361 #define _GLIBCXX_TO_CHARS(T) \
362  inline to_chars_result \
363  to_chars(char* __first, char* __last, T __value, int __base = 10) \
364  { return std::__to_chars_i<T>(__first, __last, __value, __base); }
365 _GLIBCXX_TO_CHARS(char)
366 _GLIBCXX_TO_CHARS(signed char)
367 _GLIBCXX_TO_CHARS(unsigned char)
368 _GLIBCXX_TO_CHARS(signed short)
369 _GLIBCXX_TO_CHARS(unsigned short)
370 _GLIBCXX_TO_CHARS(signed int)
371 _GLIBCXX_TO_CHARS(unsigned int)
372 _GLIBCXX_TO_CHARS(signed long)
373 _GLIBCXX_TO_CHARS(unsigned long)
374 _GLIBCXX_TO_CHARS(signed long long)
375 _GLIBCXX_TO_CHARS(unsigned long long)
376 #if defined(__GLIBCXX_TYPE_INT_N_0)
377 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_0)
378 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_0)
379 #endif
380 #if defined(__GLIBCXX_TYPE_INT_N_1)
381 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_1)
382 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_1)
383 #endif
384 #if defined(__GLIBCXX_TYPE_INT_N_2)
385 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_2)
386 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_2)
387 #endif
388 #if defined(__GLIBCXX_TYPE_INT_N_3)
389 _GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_3)
390 _GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_3)
391 #endif
392 #undef _GLIBCXX_TO_CHARS
393 
394  // _GLIBCXX_RESOLVE_LIB_DEFECTS
395  // 3266. to_chars(bool) should be deleted
396  to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
397 
398 namespace __detail
399 {
400  template<typename _Tp>
401  bool
402  __raise_and_add(_Tp& __val, int __base, unsigned char __c)
403  {
404  if (__builtin_mul_overflow(__val, __base, &__val)
405  || __builtin_add_overflow(__val, __c, &__val))
406  return false;
407  return true;
408  }
409 
410  /// std::from_chars implementation for integers in base 2.
411  template<typename _Tp>
412  bool
413  __from_chars_binary(const char*& __first, const char* __last, _Tp& __val)
414  {
415  static_assert(is_integral<_Tp>::value, "implementation bug");
416  static_assert(is_unsigned<_Tp>::value, "implementation bug");
417 
418  const ptrdiff_t __len = __last - __first;
419  ptrdiff_t __i = 0;
420  while (__i < __len && __first[__i] == '0')
421  ++__i;
422  const ptrdiff_t __leading_zeroes = __i;
423 
424  while (__i < __len)
425  {
426  const unsigned char __c = (unsigned)__first[__i] - '0';
427  if (__c < 2)
428  __val = (__val << 1) | __c;
429  else
430  break;
431  __i++;
432  }
433  __first += __i;
434  return (__i - __leading_zeroes) <= __gnu_cxx::__int_traits<_Tp>::__digits;
435  }
436 
437  /// std::from_chars implementation for integers in bases 3 to 10.
438  template<typename _Tp>
439  bool
440  __from_chars_digit(const char*& __first, const char* __last, _Tp& __val,
441  int __base)
442  {
443  static_assert(is_integral<_Tp>::value, "implementation bug");
444  static_assert(is_unsigned<_Tp>::value, "implementation bug");
445 
446  auto __matches = [__base](char __c) {
447  return '0' <= __c && __c <= ('0' + (__base - 1));
448  };
449 
450  while (__first != __last)
451  {
452  const char __c = *__first;
453  if (__matches(__c))
454  {
455  if (!__raise_and_add(__val, __base, __c - '0'))
456  {
457  while (++__first != __last && __matches(*__first))
458  ;
459  return false;
460  }
461  __first++;
462  }
463  else
464  return true;
465  }
466  return true;
467  }
468 
469  constexpr unsigned char
470  __from_chars_alpha_to_num(char __c)
471  {
472  switch (__c)
473  {
474  case 'a':
475  case 'A':
476  return 10;
477  case 'b':
478  case 'B':
479  return 11;
480  case 'c':
481  case 'C':
482  return 12;
483  case 'd':
484  case 'D':
485  return 13;
486  case 'e':
487  case 'E':
488  return 14;
489  case 'f':
490  case 'F':
491  return 15;
492  case 'g':
493  case 'G':
494  return 16;
495  case 'h':
496  case 'H':
497  return 17;
498  case 'i':
499  case 'I':
500  return 18;
501  case 'j':
502  case 'J':
503  return 19;
504  case 'k':
505  case 'K':
506  return 20;
507  case 'l':
508  case 'L':
509  return 21;
510  case 'm':
511  case 'M':
512  return 22;
513  case 'n':
514  case 'N':
515  return 23;
516  case 'o':
517  case 'O':
518  return 24;
519  case 'p':
520  case 'P':
521  return 25;
522  case 'q':
523  case 'Q':
524  return 26;
525  case 'r':
526  case 'R':
527  return 27;
528  case 's':
529  case 'S':
530  return 28;
531  case 't':
532  case 'T':
533  return 29;
534  case 'u':
535  case 'U':
536  return 30;
537  case 'v':
538  case 'V':
539  return 31;
540  case 'w':
541  case 'W':
542  return 32;
543  case 'x':
544  case 'X':
545  return 33;
546  case 'y':
547  case 'Y':
548  return 34;
549  case 'z':
550  case 'Z':
551  return 35;
552  }
553  return __gnu_cxx::__int_traits<unsigned char>::__max;
554  }
555 
556  /// std::from_chars implementation for integers in bases 11 to 26.
557  template<typename _Tp>
558  bool
559  __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
560  int __base)
561  {
562  bool __valid = true;
563  while (__first != __last)
564  {
565  unsigned char __c = *__first;
566  if (std::isdigit(__c))
567  __c -= '0';
568  else
569  {
570  __c = __from_chars_alpha_to_num(__c);
571  if (__c >= __base)
572  break;
573  }
574 
575  if (__builtin_expect(__valid, 1))
576  __valid = __raise_and_add(__val, __base, __c);
577  __first++;
578  }
579  return __valid;
580  }
581 
582  template<typename _Tp>
583  using __integer_from_chars_result_type
584  = enable_if_t<__or_<__is_signed_integer<_Tp>,
585  __is_unsigned_integer<_Tp>,
586  is_same<char, remove_cv_t<_Tp>>>::value,
587  from_chars_result>;
588 
589 } // namespace __detail
590 
591  /// std::from_chars for integral types.
592  template<typename _Tp>
593  __detail::__integer_from_chars_result_type<_Tp>
594  from_chars(const char* __first, const char* __last, _Tp& __value,
595  int __base = 10)
596  {
597  __glibcxx_assert(2 <= __base && __base <= 36);
598 
599  from_chars_result __res{__first, {}};
600 
601  int __sign = 1;
602  if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
603  if (__first != __last && *__first == '-')
604  {
605  __sign = -1;
606  ++__first;
607  }
608 
609  using _Up = __detail::__unsigned_least_t<_Tp>;
610  _Up __val = 0;
611 
612  const auto __start = __first;
613  bool __valid;
614  if (__base == 2)
615  __valid = __detail::__from_chars_binary(__first, __last, __val);
616  else if (__base <= 10)
617  __valid = __detail::__from_chars_digit(__first, __last, __val, __base);
618  else
619  __valid = __detail::__from_chars_alnum(__first, __last, __val, __base);
620 
621  if (__builtin_expect(__first == __start, 0))
622  __res.ec = errc::invalid_argument;
623  else
624  {
625  __res.ptr = __first;
626  if (!__valid)
627  __res.ec = errc::result_out_of_range;
628  else
629  {
630  if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
631  {
632  _Tp __tmp;
633  if (__builtin_mul_overflow(__val, __sign, &__tmp))
634  __res.ec = errc::result_out_of_range;
635  else
636  __value = __tmp;
637  }
638  else
639  {
640  if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Up>::__max
641  > __gnu_cxx::__int_traits<_Tp>::__max)
642  {
643  if (__val > __gnu_cxx::__int_traits<_Tp>::__max)
644  __res.ec = errc::result_out_of_range;
645  else
646  __value = __val;
647  }
648  else
649  __value = __val;
650  }
651  }
652  }
653  return __res;
654  }
655 
656  /// floating-point format for primitive numerical conversion
657  enum class chars_format
658  {
659  scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
660  };
661 
662  constexpr chars_format
663  operator|(chars_format __lhs, chars_format __rhs) noexcept
664  { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }
665 
666  constexpr chars_format
667  operator&(chars_format __lhs, chars_format __rhs) noexcept
668  { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }
669 
670  constexpr chars_format
671  operator^(chars_format __lhs, chars_format __rhs) noexcept
672  { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }
673 
674  constexpr chars_format
675  operator~(chars_format __fmt) noexcept
676  { return (chars_format)~(unsigned)__fmt; }
677 
678  constexpr chars_format&
679  operator|=(chars_format& __lhs, chars_format __rhs) noexcept
680  { return __lhs = __lhs | __rhs; }
681 
682  constexpr chars_format&
683  operator&=(chars_format& __lhs, chars_format __rhs) noexcept
684  { return __lhs = __lhs & __rhs; }
685 
686  constexpr chars_format&
687  operator^=(chars_format& __lhs, chars_format __rhs) noexcept
688  { return __lhs = __lhs ^ __rhs; }
689 
690 #if _GLIBCXX_HAVE_USELOCALE
691  from_chars_result
692  from_chars(const char* __first, const char* __last, float& __value,
693  chars_format __fmt = chars_format::general) noexcept;
694 
695  from_chars_result
696  from_chars(const char* __first, const char* __last, double& __value,
697  chars_format __fmt = chars_format::general) noexcept;
698 
699  from_chars_result
700  from_chars(const char* __first, const char* __last, long double& __value,
701  chars_format __fmt = chars_format::general) noexcept;
702 #endif
703 
704 #if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
705  && __SIZE_WIDTH__ >= 32
706  // Floating-point std::to_chars
707 
708  // Overloads for float.
709  to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
710  to_chars_result to_chars(char* __first, char* __last, float __value,
711  chars_format __fmt) noexcept;
712  to_chars_result to_chars(char* __first, char* __last, float __value,
713  chars_format __fmt, int __precision) noexcept;
714 
715  // Overloads for double.
716  to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
717  to_chars_result to_chars(char* __first, char* __last, double __value,
718  chars_format __fmt) noexcept;
719  to_chars_result to_chars(char* __first, char* __last, double __value,
720  chars_format __fmt, int __precision) noexcept;
721 
722  // Overloads for long double.
723  to_chars_result to_chars(char* __first, char* __last, long double __value)
724  noexcept;
725  to_chars_result to_chars(char* __first, char* __last, long double __value,
726  chars_format __fmt) noexcept;
727  to_chars_result to_chars(char* __first, char* __last, long double __value,
728  chars_format __fmt, int __precision) noexcept;
729 #endif
730 
731 _GLIBCXX_END_NAMESPACE_VERSION
732 } // namespace std
733 #endif // C++14
734 #endif // _GLIBCXX_CHARCONV