1// Primitive numeric conversions (to_chars and from_chars) -*- C++ -*-
3// Copyright (C) 2017-2024 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/>.
25/** @file include/charconv
26 * This is a Standard C++ Library header.
29#ifndef _GLIBCXX_CHARCONV
30#define _GLIBCXX_CHARCONV 1
32#pragma GCC system_header
34#include <bits/requires_hosted.h> // for error codes
36// As an extension we support <charconv> in C++14, but this header should not
37// be included by any other library headers in C++14 mode. This ensures that
38// the names defined in this header are not added to namespace std unless a
39// user explicitly includes <charconv> in C++14 code.
40#if __cplusplus >= 201402L
43#include <bit> // for __bit_width
44#include <bits/charconv.h> // for __to_chars_len, __to_chars_10_impl
45#include <bits/error_constants.h> // for std::errc
46#include <ext/numeric_traits.h>
48#define __glibcxx_want_to_chars
49#define __glibcxx_want_constexpr_charconv
50#include <bits/version.h>
52namespace std _GLIBCXX_VISIBILITY(default)
54_GLIBCXX_BEGIN_NAMESPACE_VERSION
56 /// Result type of std::to_chars
57 struct to_chars_result
62#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
64 operator==(const to_chars_result&, const to_chars_result&) = default;
66#if __cplusplus > 202302L
67 constexpr explicit operator bool() const noexcept { return ec == errc{}; }
71 /// Result type of std::from_chars
72 struct from_chars_result
77#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
79 operator==(const from_chars_result&, const from_chars_result&) = default;
81#if __cplusplus > 202302L
82 constexpr explicit operator bool() const noexcept { return ec == errc{}; }
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
96 using _UInts = _List<unsigned int, unsigned long, unsigned long long
97#if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
101 using type = typename __select<sizeof(_Tp), _UInts>::__type;
104 template<typename _Tp>
105 using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;
107 // Generic implementation for arbitrary bases.
108 // Defined in <bits/charconv.h>.
109 template<typename _Tp>
111 __to_chars_len(_Tp __value, int __base /* = 10 */) noexcept;
113 template<typename _Tp>
115 __to_chars_len_2(_Tp __value) noexcept
116 { return std::__bit_width(__value); }
118 // Generic implementation for arbitrary bases.
119 template<typename _Tp>
120 constexpr to_chars_result
121 __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
123 static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
125 to_chars_result __res;
127 const unsigned __len = __to_chars_len(__val, __base);
129 if (__builtin_expect((__last - __first) < __len, 0))
132 __res.ec = errc::value_too_large;
136 unsigned __pos = __len - 1;
138 constexpr char __digits[] = {
139 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
140 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
141 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
142 'u', 'v', 'w', 'x', 'y', 'z'
145 while (__val >= (unsigned)__base)
147 auto const __quo = __val / __base;
148 auto const __rem = __val % __base;
149 __first[__pos--] = __digits[__rem];
152 *__first = __digits[__val];
154 __res.ptr = __first + __len;
159 template<typename _Tp>
160 constexpr to_chars_result
161 __to_chars_16(char* __first, char* __last, _Tp __val) noexcept
163 static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
165 to_chars_result __res;
167 const unsigned __len = (__to_chars_len_2(__val) + 3) / 4;
169 if (__builtin_expect((__last - __first) < __len, 0))
172 __res.ec = errc::value_too_large;
176 constexpr char __digits[] = {
177 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
178 'a', 'b', 'c', 'd', 'e', 'f'
180 unsigned __pos = __len - 1;
181 while (__val >= 0x100)
183 auto __num = __val & 0xF;
185 __first[__pos] = __digits[__num];
188 __first[__pos - 1] = __digits[__num];
193 const auto __num = __val & 0xF;
195 __first[1] = __digits[__num];
196 __first[0] = __digits[__val];
199 __first[0] = __digits[__val];
200 __res.ptr = __first + __len;
205 template<typename _Tp>
206 constexpr to_chars_result
207 __to_chars_10(char* __first, char* __last, _Tp __val) noexcept
209 static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
211 to_chars_result __res;
213 const unsigned __len = __to_chars_len(__val, 10);
215 if (__builtin_expect((__last - __first) < __len, 0))
218 __res.ec = errc::value_too_large;
222 __detail::__to_chars_10_impl(__first, __len, __val);
223 __res.ptr = __first + __len;
228 template<typename _Tp>
229 constexpr to_chars_result
230 __to_chars_8(char* __first, char* __last, _Tp __val) noexcept
232 static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
234 to_chars_result __res;
237 if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Tp>::__digits <= 16)
239 __len = __val > 077777u ? 6u
240 : __val > 07777u ? 5u
247 __len = (__to_chars_len_2(__val) + 2) / 3;
249 if (__builtin_expect((__last - __first) < __len, 0))
252 __res.ec = errc::value_too_large;
256 unsigned __pos = __len - 1;
257 while (__val >= 0100)
259 auto __num = __val & 7;
261 __first[__pos] = '0' + __num;
264 __first[__pos - 1] = '0' + __num;
269 auto const __num = __val & 7;
271 __first[1] = '0' + __num;
272 __first[0] = '0' + __val;
275 __first[0] = '0' + __val;
276 __res.ptr = __first + __len;
281 template<typename _Tp>
282 constexpr to_chars_result
283 __to_chars_2(char* __first, char* __last, _Tp __val) noexcept
285 static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
287 to_chars_result __res;
289 const unsigned __len = __to_chars_len_2(__val);
291 if (__builtin_expect((__last - __first) < __len, 0))
294 __res.ec = errc::value_too_large;
298 unsigned __pos = __len - 1;
302 __first[__pos--] = '0' + (__val & 1);
305 // First digit is always '1' because __to_chars_len_2 skips
306 // leading zero bits and std::to_chars handles zero values
310 __res.ptr = __first + __len;
315} // namespace __detail
317 template<typename _Tp>
318 constexpr to_chars_result
319 __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
321 __glibcxx_assert(2 <= __base && __base <= 36);
323 using _Up = __detail::__unsigned_least_t<_Tp>;
324 _Up __unsigned_val = __value;
326 if (__first == __last) [[__unlikely__]]
327 return { __last, errc::value_too_large };
332 return { __first + 1, errc{} };
334 else if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
338 __unsigned_val = _Up(~__value) + _Up(1);
344 return __detail::__to_chars_16(__first, __last, __unsigned_val);
346 return __detail::__to_chars_10(__first, __last, __unsigned_val);
348 return __detail::__to_chars_8(__first, __last, __unsigned_val);
350 return __detail::__to_chars_2(__first, __last, __unsigned_val);
352 return __detail::__to_chars(__first, __last, __unsigned_val, __base);
356#define _GLIBCXX_TO_CHARS(T) \
357 _GLIBCXX23_CONSTEXPR inline to_chars_result \
358 to_chars(char* __first, char* __last, T __value, int __base = 10) \
359 { return std::__to_chars_i<T>(__first, __last, __value, __base); }
360_GLIBCXX_TO_CHARS(char)
361_GLIBCXX_TO_CHARS(signed char)
362_GLIBCXX_TO_CHARS(unsigned char)
363_GLIBCXX_TO_CHARS(signed short)
364_GLIBCXX_TO_CHARS(unsigned short)
365_GLIBCXX_TO_CHARS(signed int)
366_GLIBCXX_TO_CHARS(unsigned int)
367_GLIBCXX_TO_CHARS(signed long)
368_GLIBCXX_TO_CHARS(unsigned long)
369_GLIBCXX_TO_CHARS(signed long long)
370_GLIBCXX_TO_CHARS(unsigned long long)
371#if defined(__GLIBCXX_TYPE_INT_N_0)
372_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_0)
373_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_0)
375#if defined(__GLIBCXX_TYPE_INT_N_1)
376_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_1)
377_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_1)
379#if defined(__GLIBCXX_TYPE_INT_N_2)
380_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_2)
381_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_2)
383#if defined(__GLIBCXX_TYPE_INT_N_3)
384_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_3)
385_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_3)
387#undef _GLIBCXX_TO_CHARS
389 // _GLIBCXX_RESOLVE_LIB_DEFECTS
390 // 3266. to_chars(bool) should be deleted
391 to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
395 template<typename _Tp>
397 __raise_and_add(_Tp& __val, int __base, unsigned char __c)
399 if (__builtin_mul_overflow(__val, __base, &__val)
400 || __builtin_add_overflow(__val, __c, &__val))
405 template<bool _DecOnly>
406 struct __from_chars_alnum_to_val_table
408 struct type { unsigned char __data[1u << __CHAR_BIT__] = {}; };
410 // Construct and return a lookup table that maps 0-9, A-Z and a-z to their
411 // corresponding base-36 value and maps all other characters to 127.
412 static constexpr type
415 constexpr unsigned char __lower_letters[27] = "abcdefghijklmnopqrstuvwxyz";
416 constexpr unsigned char __upper_letters[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
418 for (auto& __entry : __table.__data)
420 for (int __i = 0; __i < 10; ++__i)
421 __table.__data['0' + __i] = __i;
422 for (int __i = 0; __i < 26; ++__i)
424 __table.__data[__lower_letters[__i]] = 10 + __i;
425 __table.__data[__upper_letters[__i]] = 10 + __i;
430 // This initializer is made superficially dependent in order
431 // to prevent the compiler from wastefully constructing the
432 // table ahead of time when it's not needed.
433 static constexpr type value = (_DecOnly, _S_make_table());
436#if ! __cpp_inline_variables
437 template<bool _DecOnly>
438 const typename __from_chars_alnum_to_val_table<_DecOnly>::type
439 __from_chars_alnum_to_val_table<_DecOnly>::value;
442 // If _DecOnly is true: if the character is a decimal digit, then
443 // return its corresponding base-10 value, otherwise return a value >= 127.
444 // If _DecOnly is false: if the character is an alphanumeric digit, then
445 // return its corresponding base-36 value, otherwise return a value >= 127.
446 template<bool _DecOnly = false>
447 _GLIBCXX20_CONSTEXPR unsigned char
448 __from_chars_alnum_to_val(unsigned char __c)
450 if _GLIBCXX17_CONSTEXPR (_DecOnly)
451 return static_cast<unsigned char>(__c - '0');
453 return __from_chars_alnum_to_val_table<_DecOnly>::value.__data[__c];
456 /// std::from_chars implementation for integers in a power-of-two base.
457 /// If _DecOnly is true, then we may assume __base is at most 8.
458 template<bool _DecOnly, typename _Tp>
459 _GLIBCXX23_CONSTEXPR bool
460 __from_chars_pow2_base(const char*& __first, const char* __last, _Tp& __val,
463 static_assert(is_integral<_Tp>::value, "implementation bug");
464 static_assert(is_unsigned<_Tp>::value, "implementation bug");
466 // __glibcxx_assert((__base & (__base - 1)) == 0);
467 // __glibcxx_assert(_DecOnly ? __base <= 8 : __base <= 32);
468 const int __log2_base = __countr_zero(unsigned(__base & 0x3f));
470 const ptrdiff_t __len = __last - __first;
472 while (__i < __len && __first[__i] == '0')
474 const ptrdiff_t __leading_zeroes = __i;
475 if (__i >= __len) [[__unlikely__]]
481 // Remember the leading significant digit value if necessary.
482 unsigned char __leading_c = 0;
485 __leading_c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);
486 // __glibcxx_assert(__leading_c != 0);
487 if (__leading_c >= __base) [[__unlikely__]]
496 for (; __i < __len; ++__i)
498 const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);
501 __val = (__val << __log2_base) | __c;
504 auto __significant_bits = (__i - __leading_zeroes) * __log2_base;
506 // Compensate for a leading significant digit that didn't use all
507 // of its available bits.
508 __significant_bits -= __log2_base - __bit_width(__leading_c);
509 // __glibcxx_assert(__significant_bits >= 0);
510 return __significant_bits <= __gnu_cxx::__int_traits<_Tp>::__digits;
513 /// std::from_chars implementation for integers in any base.
514 /// If _DecOnly is true, then we may assume __base is at most 10.
515 template<bool _DecOnly, typename _Tp>
517 __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
520 // __glibcxx_assert(_DecOnly ? __base <= 10 : __base <= 36);
522 const int __bits_per_digit = __bit_width(unsigned(__base & 0x3f));
523 int __unused_bits_lower_bound = __gnu_cxx::__int_traits<_Tp>::__digits;
524 for (; __first != __last; ++__first)
526 const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(*__first);
530 __unused_bits_lower_bound -= __bits_per_digit;
531 if (__unused_bits_lower_bound >= 0) [[__likely__]]
532 // We're definitely not going to overflow.
533 __val = __val * __base + __c;
534 else if (!__raise_and_add(__val, __base, __c)) [[__unlikely__]]
536 while (++__first != __last
537 && __from_chars_alnum_to_val<_DecOnly>(*__first) < __base)
545} // namespace __detail
547 /// std::from_chars for integral types.
548 template<typename _Tp,
549 enable_if_t<__or_<__is_standard_integer<_Tp>,
550 is_same<char, remove_cv_t<_Tp>>>::value, int> = 0>
551 _GLIBCXX23_CONSTEXPR from_chars_result
552 from_chars(const char* __first, const char* __last, _Tp& __value,
555 __glibcxx_assert(2 <= __base && __base <= 36);
557 from_chars_result __res{__first, {}};
560 if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
561 if (__first != __last && *__first == '-')
567 using _Up = __detail::__unsigned_least_t<_Tp>;
570 const auto __start = __first;
572 if ((__base & (__base - 1)) == 0)
575 __valid = __detail::__from_chars_pow2_base<true>(__first, __last, __val, __base);
577 __valid = __detail::__from_chars_pow2_base<false>(__first, __last, __val, __base);
579 else if (__base <= 10)
580 __valid = __detail::__from_chars_alnum<true>(__first, __last, __val, __base);
582 __valid = __detail::__from_chars_alnum<false>(__first, __last, __val, __base);
584 if (__builtin_expect(__first == __start, 0))
585 __res.ec = errc::invalid_argument;
590 __res.ec = errc::result_out_of_range;
593 if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
596 if (__builtin_mul_overflow(__val, __sign, &__tmp))
597 __res.ec = errc::result_out_of_range;
603 if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Up>::__max
604 > __gnu_cxx::__int_traits<_Tp>::__max)
606 if (__val > __gnu_cxx::__int_traits<_Tp>::__max)
607 __res.ec = errc::result_out_of_range;
619 /// floating-point format for primitive numerical conversion
620 enum class chars_format
622 scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
625 constexpr chars_format
626 operator|(chars_format __lhs, chars_format __rhs) noexcept
627 { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }
629 constexpr chars_format
630 operator&(chars_format __lhs, chars_format __rhs) noexcept
631 { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }
633 constexpr chars_format
634 operator^(chars_format __lhs, chars_format __rhs) noexcept
635 { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }
637 constexpr chars_format
638 operator~(chars_format __fmt) noexcept
639 { return (chars_format)~(unsigned)__fmt; }
641 constexpr chars_format&
642 operator|=(chars_format& __lhs, chars_format __rhs) noexcept
643 { return __lhs = __lhs | __rhs; }
645 constexpr chars_format&
646 operator&=(chars_format& __lhs, chars_format __rhs) noexcept
647 { return __lhs = __lhs & __rhs; }
649 constexpr chars_format&
650 operator^=(chars_format& __lhs, chars_format __rhs) noexcept
651 { return __lhs = __lhs ^ __rhs; }
653#if defined __cpp_lib_to_chars || _GLIBCXX_HAVE_USELOCALE
655 from_chars(const char* __first, const char* __last, float& __value,
656 chars_format __fmt = chars_format::general) noexcept;
659 from_chars(const char* __first, const char* __last, double& __value,
660 chars_format __fmt = chars_format::general) noexcept;
663 from_chars(const char* __first, const char* __last, long double& __value,
664 chars_format __fmt = chars_format::general) noexcept;
666 // Library routines for 16-bit extended floating point formats
667 // using float as interchange format.
669 __from_chars_float16_t(const char* __first, const char* __last,
671 chars_format __fmt = chars_format::general) noexcept;
673 __from_chars_bfloat16_t(const char* __first, const char* __last,
675 chars_format __fmt = chars_format::general) noexcept;
677#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) \
678 && defined(__cpp_lib_to_chars)
679 inline from_chars_result
680 from_chars(const char* __first, const char* __last, _Float16& __value,
681 chars_format __fmt = chars_format::general) noexcept
684 from_chars_result __res
685 = __from_chars_float16_t(__first, __last, __val, __fmt);
686 if (__res.ec == errc{})
687 __value = _Float16(__val);
692#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
693 inline from_chars_result
694 from_chars(const char* __first, const char* __last, _Float32& __value,
695 chars_format __fmt = chars_format::general) noexcept
698 from_chars_result __res = from_chars(__first, __last, __val, __fmt);
699 if (__res.ec == errc{})
700 __value = _Float32(__val);
705#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
706 inline from_chars_result
707 from_chars(const char* __first, const char* __last, _Float64& __value,
708 chars_format __fmt = chars_format::general) noexcept
711 from_chars_result __res = from_chars(__first, __last, __val, __fmt);
712 if (__res.ec == errc{})
713 __value = _Float64(__val);
718#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
719 inline from_chars_result
720 from_chars(const char* __first, const char* __last, _Float128& __value,
721 chars_format __fmt = chars_format::general) noexcept
724 from_chars_result __res = from_chars(__first, __last, __val, __fmt);
725 if (__res.ec == errc{})
726 __value = _Float128(__val);
729#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
730#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
731 __extension__ from_chars_result
732 from_chars(const char* __first, const char* __last, __ieee128& __value,
733 chars_format __fmt = chars_format::general) noexcept;
735 inline from_chars_result
736 from_chars(const char* __first, const char* __last, _Float128& __value,
737 chars_format __fmt = chars_format::general) noexcept
739 __extension__ __ieee128 __val;
740 from_chars_result __res = from_chars(__first, __last, __val, __fmt);
741 if (__res.ec == errc{})
742 __value = _Float128(__val);
747 from_chars(const char* __first, const char* __last, _Float128& __value,
748 chars_format __fmt = chars_format::general) noexcept;
752#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) \
753 && defined(__cpp_lib_to_chars)
754 inline from_chars_result
755 from_chars(const char* __first, const char* __last,
756 __gnu_cxx::__bfloat16_t & __value,
757 chars_format __fmt = chars_format::general) noexcept
760 from_chars_result __res
761 = __from_chars_bfloat16_t(__first, __last, __val, __fmt);
762 if (__res.ec == errc{})
763 __value = __gnu_cxx::__bfloat16_t(__val);
769#if defined __cpp_lib_to_chars
770 // Floating-point std::to_chars
772 // Overloads for float.
773 to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
774 to_chars_result to_chars(char* __first, char* __last, float __value,
775 chars_format __fmt) noexcept;
776 to_chars_result to_chars(char* __first, char* __last, float __value,
777 chars_format __fmt, int __precision) noexcept;
779 // Overloads for double.
780 to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
781 to_chars_result to_chars(char* __first, char* __last, double __value,
782 chars_format __fmt) noexcept;
783 to_chars_result to_chars(char* __first, char* __last, double __value,
784 chars_format __fmt, int __precision) noexcept;
786 // Overloads for long double.
787 to_chars_result to_chars(char* __first, char* __last, long double __value)
789 to_chars_result to_chars(char* __first, char* __last, long double __value,
790 chars_format __fmt) noexcept;
791 to_chars_result to_chars(char* __first, char* __last, long double __value,
792 chars_format __fmt, int __precision) noexcept;
794 // Library routines for 16-bit extended floating point formats
795 // using float as interchange format.
796 to_chars_result __to_chars_float16_t(char* __first, char* __last,
798 chars_format __fmt) noexcept;
799 to_chars_result __to_chars_bfloat16_t(char* __first, char* __last,
801 chars_format __fmt) noexcept;
803#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
804 inline to_chars_result
805 to_chars(char* __first, char* __last, _Float16 __value) noexcept
807 return __to_chars_float16_t(__first, __last, float(__value),
810 inline to_chars_result
811 to_chars(char* __first, char* __last, _Float16 __value,
812 chars_format __fmt) noexcept
813 { return __to_chars_float16_t(__first, __last, float(__value), __fmt); }
814 inline to_chars_result
815 to_chars(char* __first, char* __last, _Float16 __value,
816 chars_format __fmt, int __precision) noexcept
817 { return to_chars(__first, __last, float(__value), __fmt, __precision); }
820#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
821 inline to_chars_result
822 to_chars(char* __first, char* __last, _Float32 __value) noexcept
823 { return to_chars(__first, __last, float(__value)); }
824 inline to_chars_result
825 to_chars(char* __first, char* __last, _Float32 __value,
826 chars_format __fmt) noexcept
827 { return to_chars(__first, __last, float(__value), __fmt); }
828 inline to_chars_result
829 to_chars(char* __first, char* __last, _Float32 __value,
830 chars_format __fmt, int __precision) noexcept
831 { return to_chars(__first, __last, float(__value), __fmt, __precision); }
834#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
835 inline to_chars_result
836 to_chars(char* __first, char* __last, _Float64 __value) noexcept
837 { return to_chars(__first, __last, double(__value)); }
838 inline to_chars_result
839 to_chars(char* __first, char* __last, _Float64 __value,
840 chars_format __fmt) noexcept
841 { return to_chars(__first, __last, double(__value), __fmt); }
842 inline to_chars_result
843 to_chars(char* __first, char* __last, _Float64 __value,
844 chars_format __fmt, int __precision) noexcept
845 { return to_chars(__first, __last, double(__value), __fmt, __precision); }
848#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
849 inline to_chars_result
850 to_chars(char* __first, char* __last, _Float128 __value) noexcept
851 { return to_chars(__first, __last, static_cast<long double>(__value)); }
852 inline to_chars_result
853 to_chars(char* __first, char* __last, _Float128 __value,
854 chars_format __fmt) noexcept
856 return to_chars(__first, __last, static_cast<long double>(__value), __fmt);
858 inline to_chars_result
859 to_chars(char* __first, char* __last, _Float128 __value,
860 chars_format __fmt, int __precision) noexcept
862 return to_chars(__first, __last, static_cast<long double>(__value), __fmt,
865#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
866#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
867 __extension__ to_chars_result
868 to_chars(char* __first, char* __last, __float128 __value) noexcept;
869 __extension__ to_chars_result
870 to_chars(char* __first, char* __last, __float128 __value,
871 chars_format __fmt) noexcept;
872 __extension__ to_chars_result
873 to_chars(char* __first, char* __last, __float128 __value,
874 chars_format __fmt, int __precision) noexcept;
876 inline to_chars_result
877 to_chars(char* __first, char* __last, _Float128 __value) noexcept
879 return __extension__ to_chars(__first, __last,
880 static_cast<__float128>(__value));
882 inline to_chars_result
883 to_chars(char* __first, char* __last, _Float128 __value,
884 chars_format __fmt) noexcept
887 return __extension__ to_chars(__first, __last,
888 static_cast<__float128>(__value), __fmt);
890 inline to_chars_result
891 to_chars(char* __first, char* __last, _Float128 __value,
892 chars_format __fmt, int __precision) noexcept
895 return __extension__ to_chars(__first, __last,
896 static_cast<__float128>(__value), __fmt,
900 to_chars_result to_chars(char* __first, char* __last, _Float128 __value)
902 to_chars_result to_chars(char* __first, char* __last, _Float128 __value,
903 chars_format __fmt) noexcept;
904 to_chars_result to_chars(char* __first, char* __last, _Float128 __value,
905 chars_format __fmt, int __precision) noexcept;
909#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
910 inline to_chars_result
911 to_chars(char* __first, char* __last,
912 __gnu_cxx::__bfloat16_t __value) noexcept
914 return __to_chars_bfloat16_t(__first, __last, float(__value),
917 inline to_chars_result
918 to_chars(char* __first, char* __last, __gnu_cxx::__bfloat16_t __value,
919 chars_format __fmt) noexcept
920 { return __to_chars_bfloat16_t(__first, __last, float(__value), __fmt); }
921 inline to_chars_result
922 to_chars(char* __first, char* __last, __gnu_cxx::__bfloat16_t __value,
923 chars_format __fmt, int __precision) noexcept
924 { return to_chars(__first, __last, float(__value), __fmt, __precision); }
928_GLIBCXX_END_NAMESPACE_VERSION
931#endif // _GLIBCXX_CHARCONV