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
626 constexpr chars_format
627 operator|(chars_format __lhs, chars_format __rhs) noexcept
628 { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }
631 constexpr chars_format
632 operator&(chars_format __lhs, chars_format __rhs) noexcept
633 { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }
636 constexpr chars_format
637 operator^(chars_format __lhs, chars_format __rhs) noexcept
638 { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }
641 constexpr chars_format
642 operator~(chars_format __fmt) noexcept
643 { return (chars_format)~(unsigned)__fmt; }
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 constexpr chars_format&
654 operator^=(chars_format& __lhs, chars_format __rhs) noexcept
655 { return __lhs = __lhs ^ __rhs; }
657#if defined __cpp_lib_to_chars || _GLIBCXX_HAVE_USELOCALE
659 from_chars(const char* __first, const char* __last, float& __value,
660 chars_format __fmt = chars_format::general) noexcept;
663 from_chars(const char* __first, const char* __last, double& __value,
664 chars_format __fmt = chars_format::general) noexcept;
667 from_chars(const char* __first, const char* __last, long double& __value,
668 chars_format __fmt = chars_format::general) noexcept;
670 // Library routines for 16-bit extended floating point formats
671 // using float as interchange format.
673 __from_chars_float16_t(const char* __first, const char* __last,
675 chars_format __fmt = chars_format::general) noexcept;
677 __from_chars_bfloat16_t(const char* __first, const char* __last,
679 chars_format __fmt = chars_format::general) noexcept;
681#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) \
682 && defined(__cpp_lib_to_chars)
683 inline from_chars_result
684 from_chars(const char* __first, const char* __last, _Float16& __value,
685 chars_format __fmt = chars_format::general) noexcept
688 from_chars_result __res
689 = __from_chars_float16_t(__first, __last, __val, __fmt);
690 if (__res.ec == errc{})
691 __value = _Float16(__val);
696#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
697 inline from_chars_result
698 from_chars(const char* __first, const char* __last, _Float32& __value,
699 chars_format __fmt = chars_format::general) noexcept
702 from_chars_result __res = from_chars(__first, __last, __val, __fmt);
703 if (__res.ec == errc{})
704 __value = _Float32(__val);
709#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
710 inline from_chars_result
711 from_chars(const char* __first, const char* __last, _Float64& __value,
712 chars_format __fmt = chars_format::general) noexcept
715 from_chars_result __res = from_chars(__first, __last, __val, __fmt);
716 if (__res.ec == errc{})
717 __value = _Float64(__val);
722#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
723 inline from_chars_result
724 from_chars(const char* __first, const char* __last, _Float128& __value,
725 chars_format __fmt = chars_format::general) noexcept
728 from_chars_result __res = from_chars(__first, __last, __val, __fmt);
729 if (__res.ec == errc{})
730 __value = _Float128(__val);
733#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
734#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
735 __extension__ from_chars_result
736 from_chars(const char* __first, const char* __last, __ieee128& __value,
737 chars_format __fmt = chars_format::general) noexcept;
739 inline from_chars_result
740 from_chars(const char* __first, const char* __last, _Float128& __value,
741 chars_format __fmt = chars_format::general) noexcept
743 __extension__ __ieee128 __val;
744 from_chars_result __res = from_chars(__first, __last, __val, __fmt);
745 if (__res.ec == errc{})
746 __value = _Float128(__val);
751 from_chars(const char* __first, const char* __last, _Float128& __value,
752 chars_format __fmt = chars_format::general) noexcept;
756#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) \
757 && defined(__cpp_lib_to_chars)
758 inline from_chars_result
759 from_chars(const char* __first, const char* __last,
760 __gnu_cxx::__bfloat16_t & __value,
761 chars_format __fmt = chars_format::general) noexcept
764 from_chars_result __res
765 = __from_chars_bfloat16_t(__first, __last, __val, __fmt);
766 if (__res.ec == errc{})
767 __value = __gnu_cxx::__bfloat16_t(__val);
773#if defined __cpp_lib_to_chars
774 // Floating-point std::to_chars
776 // Overloads for float.
777 to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
778 to_chars_result to_chars(char* __first, char* __last, float __value,
779 chars_format __fmt) noexcept;
780 to_chars_result to_chars(char* __first, char* __last, float __value,
781 chars_format __fmt, int __precision) noexcept;
783 // Overloads for double.
784 to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
785 to_chars_result to_chars(char* __first, char* __last, double __value,
786 chars_format __fmt) noexcept;
787 to_chars_result to_chars(char* __first, char* __last, double __value,
788 chars_format __fmt, int __precision) noexcept;
790 // Overloads for long double.
791 to_chars_result to_chars(char* __first, char* __last, long double __value)
793 to_chars_result to_chars(char* __first, char* __last, long double __value,
794 chars_format __fmt) noexcept;
795 to_chars_result to_chars(char* __first, char* __last, long double __value,
796 chars_format __fmt, int __precision) noexcept;
798 // Library routines for 16-bit extended floating point formats
799 // using float as interchange format.
800 to_chars_result __to_chars_float16_t(char* __first, char* __last,
802 chars_format __fmt) noexcept;
803 to_chars_result __to_chars_bfloat16_t(char* __first, char* __last,
805 chars_format __fmt) noexcept;
807#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
808 inline to_chars_result
809 to_chars(char* __first, char* __last, _Float16 __value) noexcept
811 return __to_chars_float16_t(__first, __last, float(__value),
814 inline to_chars_result
815 to_chars(char* __first, char* __last, _Float16 __value,
816 chars_format __fmt) noexcept
817 { return __to_chars_float16_t(__first, __last, float(__value), __fmt); }
818 inline to_chars_result
819 to_chars(char* __first, char* __last, _Float16 __value,
820 chars_format __fmt, int __precision) noexcept
821 { return to_chars(__first, __last, float(__value), __fmt, __precision); }
824#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
825 inline to_chars_result
826 to_chars(char* __first, char* __last, _Float32 __value) noexcept
827 { return to_chars(__first, __last, float(__value)); }
828 inline to_chars_result
829 to_chars(char* __first, char* __last, _Float32 __value,
830 chars_format __fmt) noexcept
831 { return to_chars(__first, __last, float(__value), __fmt); }
832 inline to_chars_result
833 to_chars(char* __first, char* __last, _Float32 __value,
834 chars_format __fmt, int __precision) noexcept
835 { return to_chars(__first, __last, float(__value), __fmt, __precision); }
838#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
839 inline to_chars_result
840 to_chars(char* __first, char* __last, _Float64 __value) noexcept
841 { return to_chars(__first, __last, double(__value)); }
842 inline to_chars_result
843 to_chars(char* __first, char* __last, _Float64 __value,
844 chars_format __fmt) noexcept
845 { return to_chars(__first, __last, double(__value), __fmt); }
846 inline to_chars_result
847 to_chars(char* __first, char* __last, _Float64 __value,
848 chars_format __fmt, int __precision) noexcept
849 { return to_chars(__first, __last, double(__value), __fmt, __precision); }
852#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
853 inline to_chars_result
854 to_chars(char* __first, char* __last, _Float128 __value) noexcept
855 { return to_chars(__first, __last, static_cast<long double>(__value)); }
856 inline to_chars_result
857 to_chars(char* __first, char* __last, _Float128 __value,
858 chars_format __fmt) noexcept
860 return to_chars(__first, __last, static_cast<long double>(__value), __fmt);
862 inline to_chars_result
863 to_chars(char* __first, char* __last, _Float128 __value,
864 chars_format __fmt, int __precision) noexcept
866 return to_chars(__first, __last, static_cast<long double>(__value), __fmt,
869#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
870#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
871 __extension__ to_chars_result
872 to_chars(char* __first, char* __last, __float128 __value) noexcept;
873 __extension__ to_chars_result
874 to_chars(char* __first, char* __last, __float128 __value,
875 chars_format __fmt) noexcept;
876 __extension__ to_chars_result
877 to_chars(char* __first, char* __last, __float128 __value,
878 chars_format __fmt, int __precision) noexcept;
880 inline to_chars_result
881 to_chars(char* __first, char* __last, _Float128 __value) noexcept
883 return __extension__ to_chars(__first, __last,
884 static_cast<__float128>(__value));
886 inline to_chars_result
887 to_chars(char* __first, char* __last, _Float128 __value,
888 chars_format __fmt) noexcept
891 return __extension__ to_chars(__first, __last,
892 static_cast<__float128>(__value), __fmt);
894 inline to_chars_result
895 to_chars(char* __first, char* __last, _Float128 __value,
896 chars_format __fmt, int __precision) noexcept
899 return __extension__ to_chars(__first, __last,
900 static_cast<__float128>(__value), __fmt,
904 to_chars_result to_chars(char* __first, char* __last, _Float128 __value)
906 to_chars_result to_chars(char* __first, char* __last, _Float128 __value,
907 chars_format __fmt) noexcept;
908 to_chars_result to_chars(char* __first, char* __last, _Float128 __value,
909 chars_format __fmt, int __precision) noexcept;
913#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
914 inline to_chars_result
915 to_chars(char* __first, char* __last,
916 __gnu_cxx::__bfloat16_t __value) noexcept
918 return __to_chars_bfloat16_t(__first, __last, float(__value),
921 inline to_chars_result
922 to_chars(char* __first, char* __last, __gnu_cxx::__bfloat16_t __value,
923 chars_format __fmt) noexcept
924 { return __to_chars_bfloat16_t(__first, __last, float(__value), __fmt); }
925 inline to_chars_result
926 to_chars(char* __first, char* __last, __gnu_cxx::__bfloat16_t __value,
927 chars_format __fmt, int __precision) noexcept
928 { return to_chars(__first, __last, float(__value), __fmt, __precision); }
932_GLIBCXX_END_NAMESPACE_VERSION
935#endif // _GLIBCXX_CHARCONV