946 lines
30 KiB
C++
946 lines
30 KiB
C++
// Primitive numeric conversions (to_chars and from_chars) -*- C++ -*-
|
|
|
|
// Copyright (C) 2017-2023 Free Software Foundation, Inc.
|
|
//
|
|
// This file is part of the GNU ISO C++ Library. This library is free
|
|
// software; you can redistribute it and/or modify it under the
|
|
// terms of the GNU General Public License as published by the
|
|
// Free Software Foundation; either version 3, or (at your option)
|
|
// any later version.
|
|
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// Under Section 7 of GPL version 3, you are granted additional
|
|
// permissions described in the GCC Runtime Library Exception, version
|
|
// 3.1, as published by the Free Software Foundation.
|
|
|
|
// You should have received a copy of the GNU General Public License and
|
|
// a copy of the GCC Runtime Library Exception along with this program;
|
|
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
// <http://www.gnu.org/licenses/>.
|
|
|
|
/** @file include/charconv
|
|
* This is a Standard C++ Library header.
|
|
*/
|
|
|
|
#ifndef _GLIBCXX_CHARCONV
|
|
#define _GLIBCXX_CHARCONV 1
|
|
|
|
#pragma GCC system_header
|
|
|
|
#include <bits/requires_hosted.h> // for error codes
|
|
|
|
// As an extension we support <charconv> in C++14, but this header should not
|
|
// be included by any other library headers in C++14 mode. This ensures that
|
|
// the names defined in this header are not added to namespace std unless a
|
|
// user explicitly includes <charconv> in C++14 code.
|
|
#if __cplusplus >= 201402L
|
|
|
|
#include <type_traits>
|
|
#include <bit> // for __bit_width
|
|
#include <bits/charconv.h> // for __to_chars_len, __to_chars_10_impl
|
|
#include <bits/error_constants.h> // for std::errc
|
|
#include <ext/numeric_traits.h>
|
|
|
|
#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
|
|
&& __SIZE_WIDTH__ >= 32 && _GLIBCXX_HOSTED
|
|
# define __cpp_lib_to_chars 201611L
|
|
#endif
|
|
|
|
#if __cplusplus > 202002L
|
|
# define __cpp_lib_constexpr_charconv 202207L
|
|
#endif
|
|
|
|
namespace std _GLIBCXX_VISIBILITY(default)
|
|
{
|
|
_GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|
|
|
/// Result type of std::to_chars
|
|
struct to_chars_result
|
|
{
|
|
char* ptr;
|
|
errc ec;
|
|
|
|
#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
|
|
friend bool
|
|
operator==(const to_chars_result&, const to_chars_result&) = default;
|
|
#endif
|
|
};
|
|
|
|
/// Result type of std::from_chars
|
|
struct from_chars_result
|
|
{
|
|
const char* ptr;
|
|
errc ec;
|
|
|
|
#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
|
|
friend bool
|
|
operator==(const from_chars_result&, const from_chars_result&) = default;
|
|
#endif
|
|
};
|
|
|
|
namespace __detail
|
|
{
|
|
template<typename _Tp>
|
|
using __integer_to_chars_result_type
|
|
= enable_if_t<__or_<__is_signed_integer<_Tp>,
|
|
__is_unsigned_integer<_Tp>,
|
|
#if defined __SIZEOF_INT128__ && defined __STRICT_ANSI__
|
|
is_same<_Tp, signed __int128>,
|
|
is_same<_Tp, unsigned __int128>,
|
|
#endif
|
|
is_same<char, remove_cv_t<_Tp>>>::value,
|
|
to_chars_result>;
|
|
|
|
// Pick an unsigned type of suitable size. This is used to reduce the
|
|
// number of specializations of __to_chars_len, __to_chars etc. that
|
|
// get instantiated. For example, to_chars<char> and to_chars<short>
|
|
// and to_chars<unsigned> will all use the same code, and so will
|
|
// to_chars<long> when sizeof(int) == sizeof(long).
|
|
template<typename _Tp>
|
|
struct __to_chars_unsigned_type : __make_unsigned_selector_base
|
|
{
|
|
using _UInts = _List<unsigned int, unsigned long, unsigned long long
|
|
#if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
|
|
, unsigned __int128
|
|
#endif
|
|
>;
|
|
using type = typename __select<sizeof(_Tp), _UInts>::__type;
|
|
};
|
|
|
|
template<typename _Tp>
|
|
using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;
|
|
|
|
// Generic implementation for arbitrary bases.
|
|
// Defined in <bits/charconv.h>.
|
|
template<typename _Tp>
|
|
constexpr unsigned
|
|
__to_chars_len(_Tp __value, int __base /* = 10 */) noexcept;
|
|
|
|
template<typename _Tp>
|
|
constexpr unsigned
|
|
__to_chars_len_2(_Tp __value) noexcept
|
|
{ return std::__bit_width(__value); }
|
|
|
|
// Generic implementation for arbitrary bases.
|
|
template<typename _Tp>
|
|
constexpr to_chars_result
|
|
__to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
|
|
{
|
|
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
|
|
const unsigned __len = __to_chars_len(__val, __base);
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
unsigned __pos = __len - 1;
|
|
|
|
constexpr char __digits[] = {
|
|
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
|
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
|
|
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
|
|
'u', 'v', 'w', 'x', 'y', 'z'
|
|
};
|
|
|
|
while (__val >= (unsigned)__base)
|
|
{
|
|
auto const __quo = __val / __base;
|
|
auto const __rem = __val % __base;
|
|
__first[__pos--] = __digits[__rem];
|
|
__val = __quo;
|
|
}
|
|
*__first = __digits[__val];
|
|
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
constexpr __integer_to_chars_result_type<_Tp>
|
|
__to_chars_16(char* __first, char* __last, _Tp __val) noexcept
|
|
{
|
|
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
|
|
const unsigned __len = (__to_chars_len_2(__val) + 3) / 4;
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
constexpr char __digits[] = {
|
|
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
|
'a', 'b', 'c', 'd', 'e', 'f'
|
|
};
|
|
unsigned __pos = __len - 1;
|
|
while (__val >= 0x100)
|
|
{
|
|
auto __num = __val & 0xF;
|
|
__val >>= 4;
|
|
__first[__pos] = __digits[__num];
|
|
__num = __val & 0xF;
|
|
__val >>= 4;
|
|
__first[__pos - 1] = __digits[__num];
|
|
__pos -= 2;
|
|
}
|
|
if (__val >= 0x10)
|
|
{
|
|
const auto __num = __val & 0xF;
|
|
__val >>= 4;
|
|
__first[1] = __digits[__num];
|
|
__first[0] = __digits[__val];
|
|
}
|
|
else
|
|
__first[0] = __digits[__val];
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
constexpr __integer_to_chars_result_type<_Tp>
|
|
__to_chars_10(char* __first, char* __last, _Tp __val) noexcept
|
|
{
|
|
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
|
|
const unsigned __len = __to_chars_len(__val, 10);
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
__detail::__to_chars_10_impl(__first, __len, __val);
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
constexpr __integer_to_chars_result_type<_Tp>
|
|
__to_chars_8(char* __first, char* __last, _Tp __val) noexcept
|
|
{
|
|
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
unsigned __len;
|
|
|
|
if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Tp>::__digits <= 16)
|
|
{
|
|
__len = __val > 077777u ? 6u
|
|
: __val > 07777u ? 5u
|
|
: __val > 0777u ? 4u
|
|
: __val > 077u ? 3u
|
|
: __val > 07u ? 2u
|
|
: 1u;
|
|
}
|
|
else
|
|
__len = (__to_chars_len_2(__val) + 2) / 3;
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
unsigned __pos = __len - 1;
|
|
while (__val >= 0100)
|
|
{
|
|
auto __num = __val & 7;
|
|
__val >>= 3;
|
|
__first[__pos] = '0' + __num;
|
|
__num = __val & 7;
|
|
__val >>= 3;
|
|
__first[__pos - 1] = '0' + __num;
|
|
__pos -= 2;
|
|
}
|
|
if (__val >= 010)
|
|
{
|
|
auto const __num = __val & 7;
|
|
__val >>= 3;
|
|
__first[1] = '0' + __num;
|
|
__first[0] = '0' + __val;
|
|
}
|
|
else
|
|
__first[0] = '0' + __val;
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
constexpr __integer_to_chars_result_type<_Tp>
|
|
__to_chars_2(char* __first, char* __last, _Tp __val) noexcept
|
|
{
|
|
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");
|
|
|
|
to_chars_result __res;
|
|
|
|
const unsigned __len = __to_chars_len_2(__val);
|
|
|
|
if (__builtin_expect((__last - __first) < __len, 0))
|
|
{
|
|
__res.ptr = __last;
|
|
__res.ec = errc::value_too_large;
|
|
return __res;
|
|
}
|
|
|
|
unsigned __pos = __len - 1;
|
|
|
|
while (__pos)
|
|
{
|
|
__first[__pos--] = '0' + (__val & 1);
|
|
__val >>= 1;
|
|
}
|
|
// First digit is always '1' because __to_chars_len_2 skips
|
|
// leading zero bits and std::to_chars handles zero values
|
|
// directly.
|
|
__first[0] = '1';
|
|
|
|
__res.ptr = __first + __len;
|
|
__res.ec = {};
|
|
return __res;
|
|
}
|
|
|
|
} // namespace __detail
|
|
|
|
template<typename _Tp>
|
|
constexpr __detail::__integer_to_chars_result_type<_Tp>
|
|
__to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
|
|
{
|
|
__glibcxx_assert(2 <= __base && __base <= 36);
|
|
|
|
using _Up = __detail::__unsigned_least_t<_Tp>;
|
|
_Up __unsigned_val = __value;
|
|
|
|
if (__first == __last) [[__unlikely__]]
|
|
return { __last, errc::value_too_large };
|
|
|
|
if (__value == 0)
|
|
{
|
|
*__first = '0';
|
|
return { __first + 1, errc{} };
|
|
}
|
|
else if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
|
|
if (__value < 0)
|
|
{
|
|
*__first++ = '-';
|
|
__unsigned_val = _Up(~__value) + _Up(1);
|
|
}
|
|
|
|
switch (__base)
|
|
{
|
|
case 16:
|
|
return __detail::__to_chars_16(__first, __last, __unsigned_val);
|
|
case 10:
|
|
return __detail::__to_chars_10(__first, __last, __unsigned_val);
|
|
case 8:
|
|
return __detail::__to_chars_8(__first, __last, __unsigned_val);
|
|
case 2:
|
|
return __detail::__to_chars_2(__first, __last, __unsigned_val);
|
|
default:
|
|
return __detail::__to_chars(__first, __last, __unsigned_val, __base);
|
|
}
|
|
}
|
|
|
|
#define _GLIBCXX_TO_CHARS(T) \
|
|
_GLIBCXX23_CONSTEXPR inline to_chars_result \
|
|
to_chars(char* __first, char* __last, T __value, int __base = 10) \
|
|
{ return std::__to_chars_i<T>(__first, __last, __value, __base); }
|
|
_GLIBCXX_TO_CHARS(char)
|
|
_GLIBCXX_TO_CHARS(signed char)
|
|
_GLIBCXX_TO_CHARS(unsigned char)
|
|
_GLIBCXX_TO_CHARS(signed short)
|
|
_GLIBCXX_TO_CHARS(unsigned short)
|
|
_GLIBCXX_TO_CHARS(signed int)
|
|
_GLIBCXX_TO_CHARS(unsigned int)
|
|
_GLIBCXX_TO_CHARS(signed long)
|
|
_GLIBCXX_TO_CHARS(unsigned long)
|
|
_GLIBCXX_TO_CHARS(signed long long)
|
|
_GLIBCXX_TO_CHARS(unsigned long long)
|
|
#if defined(__GLIBCXX_TYPE_INT_N_0)
|
|
_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_0)
|
|
_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_0)
|
|
#endif
|
|
#if defined(__GLIBCXX_TYPE_INT_N_1)
|
|
_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_1)
|
|
_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_1)
|
|
#endif
|
|
#if defined(__GLIBCXX_TYPE_INT_N_2)
|
|
_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_2)
|
|
_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_2)
|
|
#endif
|
|
#if defined(__GLIBCXX_TYPE_INT_N_3)
|
|
_GLIBCXX_TO_CHARS(signed __GLIBCXX_TYPE_INT_N_3)
|
|
_GLIBCXX_TO_CHARS(unsigned __GLIBCXX_TYPE_INT_N_3)
|
|
#endif
|
|
#undef _GLIBCXX_TO_CHARS
|
|
|
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS
|
|
// 3266. to_chars(bool) should be deleted
|
|
to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
|
|
|
|
namespace __detail
|
|
{
|
|
template<typename _Tp>
|
|
constexpr bool
|
|
__raise_and_add(_Tp& __val, int __base, unsigned char __c)
|
|
{
|
|
if (__builtin_mul_overflow(__val, __base, &__val)
|
|
|| __builtin_add_overflow(__val, __c, &__val))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
template<bool _DecOnly>
|
|
struct __from_chars_alnum_to_val_table
|
|
{
|
|
struct type { unsigned char __data[1u << __CHAR_BIT__] = {}; };
|
|
|
|
// Construct and return a lookup table that maps 0-9, A-Z and a-z to their
|
|
// corresponding base-36 value and maps all other characters to 127.
|
|
static constexpr type
|
|
_S_make_table()
|
|
{
|
|
constexpr unsigned char __lower_letters[27] = "abcdefghijklmnopqrstuvwxyz";
|
|
constexpr unsigned char __upper_letters[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
type __table;
|
|
for (auto& __entry : __table.__data)
|
|
__entry = 127;
|
|
for (int __i = 0; __i < 10; ++__i)
|
|
__table.__data['0' + __i] = __i;
|
|
for (int __i = 0; __i < 26; ++__i)
|
|
{
|
|
__table.__data[__lower_letters[__i]] = 10 + __i;
|
|
__table.__data[__upper_letters[__i]] = 10 + __i;
|
|
}
|
|
return __table;
|
|
}
|
|
|
|
// This initializer is made superficially dependent in order
|
|
// to prevent the compiler from wastefully constructing the
|
|
// table ahead of time when it's not needed.
|
|
static constexpr type value = (_DecOnly, _S_make_table());
|
|
};
|
|
|
|
#if ! __cpp_inline_variables
|
|
template<bool _DecOnly>
|
|
const typename __from_chars_alnum_to_val_table<_DecOnly>::type
|
|
__from_chars_alnum_to_val_table<_DecOnly>::value;
|
|
#endif
|
|
|
|
// If _DecOnly is true: if the character is a decimal digit, then
|
|
// return its corresponding base-10 value, otherwise return a value >= 127.
|
|
// If _DecOnly is false: if the character is an alphanumeric digit, then
|
|
// return its corresponding base-36 value, otherwise return a value >= 127.
|
|
template<bool _DecOnly = false>
|
|
_GLIBCXX20_CONSTEXPR unsigned char
|
|
__from_chars_alnum_to_val(unsigned char __c)
|
|
{
|
|
if _GLIBCXX17_CONSTEXPR (_DecOnly)
|
|
return static_cast<unsigned char>(__c - '0');
|
|
else
|
|
return __from_chars_alnum_to_val_table<_DecOnly>::value.__data[__c];
|
|
}
|
|
|
|
/// std::from_chars implementation for integers in a power-of-two base.
|
|
/// If _DecOnly is true, then we may assume __base is at most 8.
|
|
template<bool _DecOnly, typename _Tp>
|
|
_GLIBCXX23_CONSTEXPR bool
|
|
__from_chars_pow2_base(const char*& __first, const char* __last, _Tp& __val,
|
|
int __base)
|
|
{
|
|
static_assert(is_integral<_Tp>::value, "implementation bug");
|
|
static_assert(is_unsigned<_Tp>::value, "implementation bug");
|
|
|
|
// __glibcxx_assert((__base & (__base - 1)) == 0);
|
|
// __glibcxx_assert(_DecOnly ? __base <= 8 : __base <= 32);
|
|
const int __log2_base = __countr_zero(__base);
|
|
|
|
const ptrdiff_t __len = __last - __first;
|
|
ptrdiff_t __i = 0;
|
|
while (__i < __len && __first[__i] == '0')
|
|
++__i;
|
|
const ptrdiff_t __leading_zeroes = __i;
|
|
if (__i >= __len) [[__unlikely__]]
|
|
{
|
|
__first += __i;
|
|
return true;
|
|
}
|
|
|
|
// Remember the leading significant digit value if necessary.
|
|
unsigned char __leading_c = 0;
|
|
if (__base != 2)
|
|
{
|
|
__leading_c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);
|
|
// __glibcxx_assert(__leading_c != 0);
|
|
if (__leading_c >= __base) [[__unlikely__]]
|
|
{
|
|
__first += __i;
|
|
return true;
|
|
}
|
|
__val = __leading_c;
|
|
++__i;
|
|
}
|
|
|
|
for (; __i < __len; ++__i)
|
|
{
|
|
const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);
|
|
if (__c >= __base)
|
|
break;
|
|
__val = (__val << __log2_base) | __c;
|
|
}
|
|
__first += __i;
|
|
auto __significant_bits = (__i - __leading_zeroes) * __log2_base;
|
|
if (__base != 2)
|
|
// Compensate for a leading significant digit that didn't use all
|
|
// of its available bits.
|
|
__significant_bits -= __log2_base - __bit_width(__leading_c);
|
|
// __glibcxx_assert(__significant_bits >= 0);
|
|
return __significant_bits <= __gnu_cxx::__int_traits<_Tp>::__digits;
|
|
}
|
|
|
|
/// std::from_chars implementation for integers in any base.
|
|
/// If _DecOnly is true, then we may assume __base is at most 10.
|
|
template<bool _DecOnly, typename _Tp>
|
|
constexpr bool
|
|
__from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
|
|
int __base)
|
|
{
|
|
// __glibcxx_assert(!_DecOnly || __base <= 10);
|
|
|
|
const int __bits_per_digit = __bit_width(__base);
|
|
int __unused_bits_lower_bound = __gnu_cxx::__int_traits<_Tp>::__digits;
|
|
for (; __first != __last; ++__first)
|
|
{
|
|
const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(*__first);
|
|
if (__c >= __base)
|
|
return true;
|
|
|
|
__unused_bits_lower_bound -= __bits_per_digit;
|
|
if (__unused_bits_lower_bound >= 0) [[__likely__]]
|
|
// We're definitely not going to overflow.
|
|
__val = __val * __base + __c;
|
|
else if (!__raise_and_add(__val, __base, __c)) [[__unlikely__]]
|
|
{
|
|
while (++__first != __last
|
|
&& __from_chars_alnum_to_val<_DecOnly>(*__first) < __base)
|
|
;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template<typename _Tp>
|
|
using __integer_from_chars_result_type
|
|
= enable_if_t<__or_<__is_signed_integer<_Tp>,
|
|
__is_unsigned_integer<_Tp>,
|
|
is_same<char, remove_cv_t<_Tp>>>::value,
|
|
from_chars_result>;
|
|
|
|
} // namespace __detail
|
|
|
|
/// std::from_chars for integral types.
|
|
template<typename _Tp>
|
|
_GLIBCXX23_CONSTEXPR __detail::__integer_from_chars_result_type<_Tp>
|
|
from_chars(const char* __first, const char* __last, _Tp& __value,
|
|
int __base = 10)
|
|
{
|
|
__glibcxx_assert(2 <= __base && __base <= 36);
|
|
|
|
from_chars_result __res{__first, {}};
|
|
|
|
int __sign = 1;
|
|
if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
|
|
if (__first != __last && *__first == '-')
|
|
{
|
|
__sign = -1;
|
|
++__first;
|
|
}
|
|
|
|
using _Up = __detail::__unsigned_least_t<_Tp>;
|
|
_Up __val = 0;
|
|
|
|
const auto __start = __first;
|
|
bool __valid;
|
|
if ((__base & (__base - 1)) == 0)
|
|
{
|
|
if (__base <= 8)
|
|
__valid = __detail::__from_chars_pow2_base<true>(__first, __last, __val, __base);
|
|
else
|
|
__valid = __detail::__from_chars_pow2_base<false>(__first, __last, __val, __base);
|
|
}
|
|
else if (__base <= 10)
|
|
__valid = __detail::__from_chars_alnum<true>(__first, __last, __val, __base);
|
|
else
|
|
__valid = __detail::__from_chars_alnum<false>(__first, __last, __val, __base);
|
|
|
|
if (__builtin_expect(__first == __start, 0))
|
|
__res.ec = errc::invalid_argument;
|
|
else
|
|
{
|
|
__res.ptr = __first;
|
|
if (!__valid)
|
|
__res.ec = errc::result_out_of_range;
|
|
else
|
|
{
|
|
if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
|
|
{
|
|
_Tp __tmp;
|
|
if (__builtin_mul_overflow(__val, __sign, &__tmp))
|
|
__res.ec = errc::result_out_of_range;
|
|
else
|
|
__value = __tmp;
|
|
}
|
|
else
|
|
{
|
|
if _GLIBCXX17_CONSTEXPR (__gnu_cxx::__int_traits<_Up>::__max
|
|
> __gnu_cxx::__int_traits<_Tp>::__max)
|
|
{
|
|
if (__val > __gnu_cxx::__int_traits<_Tp>::__max)
|
|
__res.ec = errc::result_out_of_range;
|
|
else
|
|
__value = __val;
|
|
}
|
|
else
|
|
__value = __val;
|
|
}
|
|
}
|
|
}
|
|
return __res;
|
|
}
|
|
|
|
/// floating-point format for primitive numerical conversion
|
|
enum class chars_format
|
|
{
|
|
scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
|
|
};
|
|
|
|
constexpr chars_format
|
|
operator|(chars_format __lhs, chars_format __rhs) noexcept
|
|
{ return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }
|
|
|
|
constexpr chars_format
|
|
operator&(chars_format __lhs, chars_format __rhs) noexcept
|
|
{ return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }
|
|
|
|
constexpr chars_format
|
|
operator^(chars_format __lhs, chars_format __rhs) noexcept
|
|
{ return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }
|
|
|
|
constexpr chars_format
|
|
operator~(chars_format __fmt) noexcept
|
|
{ return (chars_format)~(unsigned)__fmt; }
|
|
|
|
constexpr chars_format&
|
|
operator|=(chars_format& __lhs, chars_format __rhs) noexcept
|
|
{ return __lhs = __lhs | __rhs; }
|
|
|
|
constexpr chars_format&
|
|
operator&=(chars_format& __lhs, chars_format __rhs) noexcept
|
|
{ return __lhs = __lhs & __rhs; }
|
|
|
|
constexpr chars_format&
|
|
operator^=(chars_format& __lhs, chars_format __rhs) noexcept
|
|
{ return __lhs = __lhs ^ __rhs; }
|
|
|
|
#if defined __cpp_lib_to_chars || _GLIBCXX_HAVE_USELOCALE
|
|
from_chars_result
|
|
from_chars(const char* __first, const char* __last, float& __value,
|
|
chars_format __fmt = chars_format::general) noexcept;
|
|
|
|
from_chars_result
|
|
from_chars(const char* __first, const char* __last, double& __value,
|
|
chars_format __fmt = chars_format::general) noexcept;
|
|
|
|
from_chars_result
|
|
from_chars(const char* __first, const char* __last, long double& __value,
|
|
chars_format __fmt = chars_format::general) noexcept;
|
|
|
|
// Library routines for 16-bit extended floating point formats
|
|
// using float as interchange format.
|
|
from_chars_result
|
|
__from_chars_float16_t(const char* __first, const char* __last,
|
|
float& __value,
|
|
chars_format __fmt = chars_format::general) noexcept;
|
|
from_chars_result
|
|
__from_chars_bfloat16_t(const char* __first, const char* __last,
|
|
float& __value,
|
|
chars_format __fmt = chars_format::general) noexcept;
|
|
|
|
#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) \
|
|
&& defined(__cpp_lib_to_chars)
|
|
inline from_chars_result
|
|
from_chars(const char* __first, const char* __last, _Float16& __value,
|
|
chars_format __fmt = chars_format::general) noexcept
|
|
{
|
|
float __val;
|
|
from_chars_result __res
|
|
= __from_chars_float16_t(__first, __last, __val, __fmt);
|
|
if (__res.ec == errc{})
|
|
__value = __val;
|
|
return __res;
|
|
}
|
|
#endif
|
|
|
|
#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
|
|
inline from_chars_result
|
|
from_chars(const char* __first, const char* __last, _Float32& __value,
|
|
chars_format __fmt = chars_format::general) noexcept
|
|
{
|
|
float __val;
|
|
from_chars_result __res = from_chars(__first, __last, __val, __fmt);
|
|
if (__res.ec == errc{})
|
|
__value = __val;
|
|
return __res;
|
|
}
|
|
#endif
|
|
|
|
#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
|
|
inline from_chars_result
|
|
from_chars(const char* __first, const char* __last, _Float64& __value,
|
|
chars_format __fmt = chars_format::general) noexcept
|
|
{
|
|
double __val;
|
|
from_chars_result __res = from_chars(__first, __last, __val, __fmt);
|
|
if (__res.ec == errc{})
|
|
__value = __val;
|
|
return __res;
|
|
}
|
|
#endif
|
|
|
|
#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
|
|
inline from_chars_result
|
|
from_chars(const char* __first, const char* __last, _Float128& __value,
|
|
chars_format __fmt = chars_format::general) noexcept
|
|
{
|
|
long double __val;
|
|
from_chars_result __res = from_chars(__first, __last, __val, __fmt);
|
|
if (__res.ec == errc{})
|
|
__value = __val;
|
|
return __res;
|
|
}
|
|
#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
|
|
#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
|
|
__extension__ from_chars_result
|
|
from_chars(const char* __first, const char* __last, __ieee128& __value,
|
|
chars_format __fmt = chars_format::general) noexcept;
|
|
|
|
inline from_chars_result
|
|
from_chars(const char* __first, const char* __last, _Float128& __value,
|
|
chars_format __fmt = chars_format::general) noexcept
|
|
{
|
|
__extension__ __ieee128 __val;
|
|
from_chars_result __res = from_chars(__first, __last, __val, __fmt);
|
|
if (__res.ec == errc{})
|
|
__value = __val;
|
|
return __res;
|
|
}
|
|
#else
|
|
from_chars_result
|
|
from_chars(const char* __first, const char* __last, _Float128& __value,
|
|
chars_format __fmt = chars_format::general) noexcept;
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) \
|
|
&& defined(__cpp_lib_to_chars)
|
|
inline from_chars_result
|
|
from_chars(const char* __first, const char* __last,
|
|
__gnu_cxx::__bfloat16_t & __value,
|
|
chars_format __fmt = chars_format::general) noexcept
|
|
{
|
|
float __val;
|
|
from_chars_result __res
|
|
= __from_chars_bfloat16_t(__first, __last, __val, __fmt);
|
|
if (__res.ec == errc{})
|
|
__value = __val;
|
|
return __res;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#if defined __cpp_lib_to_chars
|
|
// Floating-point std::to_chars
|
|
|
|
// Overloads for float.
|
|
to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
|
|
to_chars_result to_chars(char* __first, char* __last, float __value,
|
|
chars_format __fmt) noexcept;
|
|
to_chars_result to_chars(char* __first, char* __last, float __value,
|
|
chars_format __fmt, int __precision) noexcept;
|
|
|
|
// Overloads for double.
|
|
to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
|
|
to_chars_result to_chars(char* __first, char* __last, double __value,
|
|
chars_format __fmt) noexcept;
|
|
to_chars_result to_chars(char* __first, char* __last, double __value,
|
|
chars_format __fmt, int __precision) noexcept;
|
|
|
|
// Overloads for long double.
|
|
to_chars_result to_chars(char* __first, char* __last, long double __value)
|
|
noexcept;
|
|
to_chars_result to_chars(char* __first, char* __last, long double __value,
|
|
chars_format __fmt) noexcept;
|
|
to_chars_result to_chars(char* __first, char* __last, long double __value,
|
|
chars_format __fmt, int __precision) noexcept;
|
|
|
|
// Library routines for 16-bit extended floating point formats
|
|
// using float as interchange format.
|
|
to_chars_result __to_chars_float16_t(char* __first, char* __last,
|
|
float __value,
|
|
chars_format __fmt) noexcept;
|
|
to_chars_result __to_chars_bfloat16_t(char* __first, char* __last,
|
|
float __value,
|
|
chars_format __fmt) noexcept;
|
|
|
|
#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float16 __value) noexcept
|
|
{
|
|
return __to_chars_float16_t(__first, __last, float(__value),
|
|
chars_format{});
|
|
}
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float16 __value,
|
|
chars_format __fmt) noexcept
|
|
{ return __to_chars_float16_t(__first, __last, float(__value), __fmt); }
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float16 __value,
|
|
chars_format __fmt, int __precision) noexcept
|
|
{ return to_chars(__first, __last, float(__value), __fmt, __precision); }
|
|
#endif
|
|
|
|
#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float32 __value) noexcept
|
|
{ return to_chars(__first, __last, float(__value)); }
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float32 __value,
|
|
chars_format __fmt) noexcept
|
|
{ return to_chars(__first, __last, float(__value), __fmt); }
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float32 __value,
|
|
chars_format __fmt, int __precision) noexcept
|
|
{ return to_chars(__first, __last, float(__value), __fmt, __precision); }
|
|
#endif
|
|
|
|
#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float64 __value) noexcept
|
|
{ return to_chars(__first, __last, double(__value)); }
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float64 __value,
|
|
chars_format __fmt) noexcept
|
|
{ return to_chars(__first, __last, double(__value), __fmt); }
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float64 __value,
|
|
chars_format __fmt, int __precision) noexcept
|
|
{ return to_chars(__first, __last, double(__value), __fmt, __precision); }
|
|
#endif
|
|
|
|
#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float128 __value) noexcept
|
|
{ return to_chars(__first, __last, static_cast<long double>(__value)); }
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float128 __value,
|
|
chars_format __fmt) noexcept
|
|
{
|
|
return to_chars(__first, __last, static_cast<long double>(__value), __fmt);
|
|
}
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float128 __value,
|
|
chars_format __fmt, int __precision) noexcept
|
|
{
|
|
return to_chars(__first, __last, static_cast<long double>(__value), __fmt,
|
|
__precision);
|
|
}
|
|
#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
|
|
#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
|
|
__extension__ to_chars_result
|
|
to_chars(char* __first, char* __last, __float128 __value) noexcept;
|
|
__extension__ to_chars_result
|
|
to_chars(char* __first, char* __last, __float128 __value,
|
|
chars_format __fmt) noexcept;
|
|
__extension__ to_chars_result
|
|
to_chars(char* __first, char* __last, __float128 __value,
|
|
chars_format __fmt, int __precision) noexcept;
|
|
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float128 __value) noexcept
|
|
{
|
|
return __extension__ to_chars(__first, __last,
|
|
static_cast<__float128>(__value));
|
|
}
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float128 __value,
|
|
chars_format __fmt) noexcept
|
|
{
|
|
|
|
return __extension__ to_chars(__first, __last,
|
|
static_cast<__float128>(__value), __fmt);
|
|
}
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, _Float128 __value,
|
|
chars_format __fmt, int __precision) noexcept
|
|
{
|
|
|
|
return __extension__ to_chars(__first, __last,
|
|
static_cast<__float128>(__value), __fmt,
|
|
__precision);
|
|
}
|
|
#else
|
|
to_chars_result to_chars(char* __first, char* __last, _Float128 __value)
|
|
noexcept;
|
|
to_chars_result to_chars(char* __first, char* __last, _Float128 __value,
|
|
chars_format __fmt) noexcept;
|
|
to_chars_result to_chars(char* __first, char* __last, _Float128 __value,
|
|
chars_format __fmt, int __precision) noexcept;
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last,
|
|
__gnu_cxx::__bfloat16_t __value) noexcept
|
|
{
|
|
return __to_chars_bfloat16_t(__first, __last, float(__value),
|
|
chars_format{});
|
|
}
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, __gnu_cxx::__bfloat16_t __value,
|
|
chars_format __fmt) noexcept
|
|
{ return __to_chars_bfloat16_t(__first, __last, float(__value), __fmt); }
|
|
inline to_chars_result
|
|
to_chars(char* __first, char* __last, __gnu_cxx::__bfloat16_t __value,
|
|
chars_format __fmt, int __precision) noexcept
|
|
{ return to_chars(__first, __last, float(__value), __fmt, __precision); }
|
|
#endif
|
|
#endif
|
|
|
|
_GLIBCXX_END_NAMESPACE_VERSION
|
|
} // namespace std
|
|
#endif // C++14
|
|
#endif // _GLIBCXX_CHARCONV
|