This is an archive of the discontinued LLVM Phabricator instance.

Paths

Table of Contentst

-
libcxx/include/
-
include/
6/6
charconv

Differential D121223

[libc++][NFC] Cleanups in <charconv>.
ClosedPublic

Authored by Mordante on Mar 8 2022, 8:41 AM.

Download Raw Diff

Details

Reviewers

• Quuxplusone
philnik

Group Reviewers

Restricted Project

Commits

rG3925f98de4ac: [libc++][NFC] Cleanups in <charconv>.

Summary

Based on review comments in D97705 applied some code cleanups in
<charconv>. The header now uses a more recent libc++ style.

Diff Detail

Repository: rG LLVM Github Monorepo

Event Timeline

Mordante created this revision.Mar 8 2022, 8:41 AM

Herald added a project: Restricted Project. · View Herald TranscriptMar 8 2022, 8:41 AM

Mordante requested review of this revision.Mar 8 2022, 8:42 AM

Herald added a project: Restricted Project. · View Herald TranscriptMar 8 2022, 8:42 AM

Herald added a reviewer: Restricted Project. · View Herald Transcript

Herald added a subscriber: libcxx-commits. · View Herald Transcript

LGTM % comment.

libcxx/include/charconv
109–111	I think this fails in C++03, but I don't know why it is available in C++03 at all.

Mordante mentioned this in D97705: [libc++] Improve std::to_chars for base != 10..Mar 8 2022, 8:48 AM

LGTM if CI is happy!

libcxx/include/charconv
109–111	+1; could this be moved under the following `#if`?
171	Pre-existing, tangential: I notice that here the SFINAE is testing explicit curly-brace-initialization from `_Tp` to `uint32_t`, but what's actually used on line 184 is implicit conversion (and ADL on `_Tp`). If `_Tp` is always a built-in integer type, this is probably all fine.
323–324	Consider breaking after `int`, to match lines 308-309.

This revision is now accepted and ready to land.Mar 8 2022, 9:45 AM

Thanks for the reviews!

libcxx/include/charconv
109–111	Good point, we didn't support it in C++03, but missed the `#if` wasn't placed correctly.
171	The condition `is_integral<_Tp>::value` is `true` when this code is used. So it should be fine.

Address review comments.

Harbormaster completed remote builds in B153198: Diff 413869.Mar 8 2022, 2:19 PM

Closed by commit rG3925f98de4ac: [libc++][NFC] Cleanups in <charconv>. (authored by Mordante). · Explain WhyMar 9 2022, 8:52 AM

This revision was automatically updated to reflect the committed changes.

Mordante added a commit: rG3925f98de4ac: [libc++][NFC] Cleanups in <charconv>..

Revision Contents

Path

Size

libcxx/

include/

charconv

83 lines

Diff 414115

libcxx/include/charconv

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines
# pragma GCC system_header		# pragma GCC system_header
#endif		#endif

_LIBCPP_PUSH_MACROS		_LIBCPP_PUSH_MACROS
#include <__undef_macros>		#include <__undef_macros>

_LIBCPP_BEGIN_NAMESPACE_STD		_LIBCPP_BEGIN_NAMESPACE_STD

		#ifndef _LIBCPP_CXX03_LANG

namespace __itoa {		namespace __itoa {
_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer) _NOEXCEPT;		_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer) noexcept;
_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer) _NOEXCEPT;		_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer) noexcept;
} // namespace __itoa		} // namespace __itoa
		philnikUnsubmitted Done Reply Inline Actions I think this fails in C++03, but I don't know why it is available in C++03 at all. philnik: I think this fails in C++03, but I don't know why it is available in C++03 at all.
		QuuxplusoneUnsubmitted Done Reply Inline Actions +1; could this be moved under the following `#if`? Quuxplusone: +1; could this be moved under the following `#if`?
		MordanteAuthorUnsubmitted Done Reply Inline Actions Good point, we didn't support it in C++03, but missed the `#if` wasn't placed correctly. Mordante: Good point, we didn't support it in C++03, but missed the `#if` wasn't placed correctly.

#ifndef _LIBCPP_CXX03_LANG

to_chars_result to_chars(char, char, bool, int = 10) = delete;		to_chars_result to_chars(char, char, bool, int = 10) = delete;
from_chars_result from_chars(const char, const char, bool, int = 10) = delete;		from_chars_result from_chars(const char, const char, bool, int = 10) = delete;

namespace __itoa		namespace __itoa
{		{

static _LIBCPP_CONSTEXPR uint64_t __pow10_64[] = {		static constexpr uint64_t __pow10_64[] = {
UINT64_C(0),		UINT64_C(0),
UINT64_C(10),		UINT64_C(10),
UINT64_C(100),		UINT64_C(100),
UINT64_C(1000),		UINT64_C(1000),
UINT64_C(10000),		UINT64_C(10000),
UINT64_C(100000),		UINT64_C(100000),
UINT64_C(1000000),		UINT64_C(1000000),
UINT64_C(10000000),		UINT64_C(10000000),
UINT64_C(100000000),		UINT64_C(100000000),
UINT64_C(1000000000),		UINT64_C(1000000000),
UINT64_C(10000000000),		UINT64_C(10000000000),
UINT64_C(100000000000),		UINT64_C(100000000000),
UINT64_C(1000000000000),		UINT64_C(1000000000000),
UINT64_C(10000000000000),		UINT64_C(10000000000000),
UINT64_C(100000000000000),		UINT64_C(100000000000000),
UINT64_C(1000000000000000),		UINT64_C(1000000000000000),
UINT64_C(10000000000000000),		UINT64_C(10000000000000000),
UINT64_C(100000000000000000),		UINT64_C(100000000000000000),
UINT64_C(1000000000000000000),		UINT64_C(1000000000000000000),
UINT64_C(10000000000000000000),		UINT64_C(10000000000000000000),
};		};

static _LIBCPP_CONSTEXPR uint32_t __pow10_32[] = {		static constexpr uint32_t __pow10_32[] = {
UINT32_C(0), UINT32_C(10), UINT32_C(100),		UINT32_C(0), UINT32_C(10), UINT32_C(100),
UINT32_C(1000), UINT32_C(10000), UINT32_C(100000),		UINT32_C(1000), UINT32_C(10000), UINT32_C(100000),
UINT32_C(1000000), UINT32_C(10000000), UINT32_C(100000000),		UINT32_C(1000000), UINT32_C(10000000), UINT32_C(100000000),
UINT32_C(1000000000),		UINT32_C(1000000000),
};		};

template <typename _Tp, typename = void>		template <typename _Tp, typename = void>
struct _LIBCPP_HIDDEN __traits_base		struct _LIBCPP_HIDDEN __traits_base
{		{
using type = uint64_t;		using type = uint64_t;

static _LIBCPP_INLINE_VISIBILITY int __width(_Tp __v)		static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v)
{		{
auto __t = (64 - _VSTD::__libcpp_clz(static_cast<type>(__v \| 1))) * 1233 >> 12;		auto __t = (64 - std::__libcpp_clz(static_cast<type>(__v \| 1))) * 1233 >> 12;
return __t - (__v < __pow10_64[__t]) + 1;		return __t - (__v < __pow10_64[__t]) + 1;
}		}

_LIBCPP_AVAILABILITY_TO_CHARS		_LIBCPP_AVAILABILITY_TO_CHARS
static _LIBCPP_INLINE_VISIBILITY char* __convert(_Tp __v, char* __p)		static _LIBCPP_HIDE_FROM_ABI char* __convert(_Tp __v, char* __p)
{		{
return __u64toa(__v, __p);		return __u64toa(__v, __p);
}		}

static _LIBCPP_INLINE_VISIBILITY decltype(__pow10_64)& __pow() { return __pow10_64; }		static _LIBCPP_HIDE_FROM_ABI decltype(__pow10_64)& __pow() { return __pow10_64; }
};		};

template <typename _Tp>		template <typename _Tp>
struct _LIBCPP_HIDDEN		struct _LIBCPP_HIDDEN
__traits_base<_Tp, decltype(void(uint32_t{declval<_Tp>()}))>		__traits_base<_Tp, decltype(void(uint32_t{declval<_Tp>()}))>
		QuuxplusoneUnsubmitted Done Reply Inline Actions Pre-existing, tangential: I notice that here the SFINAE is testing explicit curly-brace-initialization from `_Tp` to `uint32_t`, but what's actually used on line 184 is implicit conversion (and ADL on `_Tp`). If `_Tp` is always a built-in integer type, this is probably all fine. Quuxplusone: Pre-existing, tangential: I notice that here the SFINAE is testing explicit curly-brace…
		MordanteAuthorUnsubmitted Done Reply Inline Actions The condition `is_integral<_Tp>::value` is `true` when this code is used. So it should be fine. Mordante: The condition `is_integral<_Tp>::value` is `true` when this code is used. So it should be fine.
{		{
using type = uint32_t;		using type = uint32_t;

static _LIBCPP_INLINE_VISIBILITY int __width(_Tp __v)		static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v)
{		{
auto __t = (32 - _VSTD::__libcpp_clz(static_cast<type>(__v \| 1))) * 1233 >> 12;		auto __t = (32 - std::__libcpp_clz(static_cast<type>(__v \| 1))) * 1233 >> 12;
return __t - (__v < __pow10_32[__t]) + 1;		return __t - (__v < __pow10_32[__t]) + 1;
}		}

_LIBCPP_AVAILABILITY_TO_CHARS		_LIBCPP_AVAILABILITY_TO_CHARS
static _LIBCPP_INLINE_VISIBILITY char* __convert(_Tp __v, char* __p)		static _LIBCPP_HIDE_FROM_ABI char* __convert(_Tp __v, char* __p)
{		{
return __u32toa(__v, __p);		return __u32toa(__v, __p);
}		}

static _LIBCPP_INLINE_VISIBILITY decltype(__pow10_32)& __pow() { return __pow10_32; }		static _LIBCPP_HIDE_FROM_ABI decltype(__pow10_32)& __pow() { return __pow10_32; }
};		};

template <typename _Tp>		template <typename _Tp>
inline _LIBCPP_INLINE_VISIBILITY bool		inline _LIBCPP_HIDE_FROM_ABI bool
__mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r)		__mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r)
{		{
auto __c = __a * __b;		auto __c = __a * __b;
__r = __c;		__r = __c;
return __c > numeric_limits<unsigned char>::max();		return __c > numeric_limits<unsigned char>::max();
}		}

template <typename _Tp>		template <typename _Tp>
inline _LIBCPP_INLINE_VISIBILITY bool		inline _LIBCPP_HIDE_FROM_ABI bool
__mul_overflowed(unsigned short __a, _Tp __b, unsigned short& __r)		__mul_overflowed(unsigned short __a, _Tp __b, unsigned short& __r)
{		{
auto __c = __a * __b;		auto __c = __a * __b;
__r = __c;		__r = __c;
return __c > numeric_limits<unsigned short>::max();		return __c > numeric_limits<unsigned short>::max();
}		}

template <typename _Tp>		template <typename _Tp>
inline _LIBCPP_INLINE_VISIBILITY bool		inline _LIBCPP_HIDE_FROM_ABI bool
__mul_overflowed(_Tp __a, _Tp __b, _Tp& __r)		__mul_overflowed(_Tp __a, _Tp __b, _Tp& __r)
{		{
static_assert(is_unsigned<_Tp>::value, "");		static_assert(is_unsigned<_Tp>::value, "");
#if !defined(_LIBCPP_COMPILER_MSVC)		#if !defined(_LIBCPP_COMPILER_MSVC)
return __builtin_mul_overflow(__a, __b, &__r);		return __builtin_mul_overflow(__a, __b, &__r);
#else		#else
bool __did = __b && (numeric_limits<_Tp>::max() / __b) < __a;		bool __did = __b && (numeric_limits<_Tp>::max() / __b) < __a;
__r = __a * __b;		__r = __a * __b;
return __did;		return __did;
#endif		#endif
}		}

template <typename _Tp, typename _Up>		template <typename _Tp, typename _Up>
inline _LIBCPP_INLINE_VISIBILITY bool		inline _LIBCPP_HIDE_FROM_ABI bool
__mul_overflowed(_Tp __a, _Up __b, _Tp& __r)		__mul_overflowed(_Tp __a, _Up __b, _Tp& __r)
{		{
return __mul_overflowed(__a, static_cast<_Tp>(__b), __r);		return __mul_overflowed(__a, static_cast<_Tp>(__b), __r);
}		}

template <typename _Tp>		template <typename _Tp>
struct _LIBCPP_HIDDEN __traits : __traits_base<_Tp>		struct _LIBCPP_HIDDEN __traits : __traits_base<_Tp>
{		{
static _LIBCPP_CONSTEXPR int digits = numeric_limits<_Tp>::digits10 + 1;		static constexpr int digits = numeric_limits<_Tp>::digits10 + 1;
using __traits_base<_Tp>::__pow;		using __traits_base<_Tp>::__pow;
using typename __traits_base<_Tp>::type;		using typename __traits_base<_Tp>::type;

// precondition: at least one non-zero character available		// precondition: at least one non-zero character available
static _LIBCPP_INLINE_VISIBILITY char const*		static _LIBCPP_HIDE_FROM_ABI char const*
__read(char const* __p, char const* __ep, type& __a, type& __b)		__read(char const* __p, char const* __ep, type& __a, type& __b)
{		{
type __cprod[digits];		type __cprod[digits];
int __j = digits - 1;		int __j = digits - 1;
int __i = digits;		int __i = digits;
do		do
{		{
if (!('0' <= __p && __p <= '9'))		if (!('0' <= __p && __p <= '9'))
break;		break;
__cprod[--__i] = *__p++ - '0';		__cprod[--__i] = *__p++ - '0';
} while (__p != __ep && __i != 0);		} while (__p != __ep && __i != 0);

__a = __inner_product(__cprod + __i + 1, __cprod + __j, __pow() + 1,		__a = __inner_product(__cprod + __i + 1, __cprod + __j, __pow() + 1,
__cprod[__i]);		__cprod[__i]);
if (__mul_overflowed(__cprod[__j], __pow()[__j - __i], __b))		if (__mul_overflowed(__cprod[__j], __pow()[__j - __i], __b))
--__p;		--__p;
return __p;		return __p;
}		}

template <typename _It1, typename _It2, class _Up>		template <typename _It1, typename _It2, class _Up>
static _LIBCPP_INLINE_VISIBILITY _Up		static _LIBCPP_HIDE_FROM_ABI _Up
__inner_product(_It1 __first1, _It1 __last1, _It2 __first2, _Up __init)		__inner_product(_It1 __first1, _It1 __last1, _It2 __first2, _Up __init)
{		{
for (; __first1 < __last1; ++__first1, ++__first2)		for (; __first1 < __last1; ++__first1, ++__first2)
__init = __init + __first1 *__first2;		__init = __init + __first1 *__first2;
return __init;		return __init;
}		}
};		};

} // namespace __itoa		} // namespace __itoa

template <typename _Tp>		template <typename _Tp>
inline _LIBCPP_INLINE_VISIBILITY _Tp		inline _LIBCPP_HIDE_FROM_ABI _Tp
__complement(_Tp __x)		__complement(_Tp __x)
{		{
static_assert(is_unsigned<_Tp>::value, "cast to unsigned first");		static_assert(is_unsigned<_Tp>::value, "cast to unsigned first");
return _Tp(~__x + 1);		return _Tp(~__x + 1);
}		}

template <typename _Tp>		template <typename _Tp>
_LIBCPP_AVAILABILITY_TO_CHARS		_LIBCPP_AVAILABILITY_TO_CHARS
inline _LIBCPP_INLINE_VISIBILITY to_chars_result		inline _LIBCPP_HIDE_FROM_ABI to_chars_result
__to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)		__to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)
{		{
auto __x = __to_unsigned_like(__value);		auto __x = __to_unsigned_like(__value);
if (__value < 0 && __first != __last)		if (__value < 0 && __first != __last)
{		{
*__first++ = '-';		*__first++ = '-';
__x = __complement(__x);		__x = __complement(__x);
}		}

return __to_chars_itoa(__first, __last, __x, false_type());		return __to_chars_itoa(__first, __last, __x, false_type());
}		}

template <typename _Tp>		template <typename _Tp>
_LIBCPP_AVAILABILITY_TO_CHARS		_LIBCPP_AVAILABILITY_TO_CHARS
inline _LIBCPP_INLINE_VISIBILITY to_chars_result		inline _LIBCPP_HIDE_FROM_ABI to_chars_result
__to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)		__to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)
{		{
using __tx = __itoa::__traits<_Tp>;		using __tx = __itoa::__traits<_Tp>;
auto __diff = __last - __first;		auto __diff = __last - __first;

if (__tx::digits <= __diff \|\| __tx::__width(__value) <= __diff)		if (__tx::digits <= __diff \|\| __tx::__width(__value) <= __diff)
return {__tx::__convert(__value, __first), errc(0)};		return {__tx::__convert(__value, __first), errc(0)};
else		else
return {__last, errc::value_too_large};		return {__last, errc::value_too_large};
}		}

template <typename _Tp>		template <typename _Tp>
_LIBCPP_AVAILABILITY_TO_CHARS		_LIBCPP_AVAILABILITY_TO_CHARS
inline _LIBCPP_INLINE_VISIBILITY to_chars_result		inline _LIBCPP_HIDE_FROM_ABI to_chars_result
__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,		__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
true_type)		true_type)
{		{
auto __x = __to_unsigned_like(__value);		auto __x = __to_unsigned_like(__value);
if (__value < 0 && __first != __last)		if (__value < 0 && __first != __last)
{		{
*__first++ = '-';		*__first++ = '-';
__x = __complement(__x);		__x = __complement(__x);
}		}

return __to_chars_integral(__first, __last, __x, __base, false_type());		return __to_chars_integral(__first, __last, __x, __base, false_type());
}		}

template <typename _Tp>		template <typename _Tp>
_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_INLINE_VISIBILITY int __to_chars_integral_width(_Tp __value, unsigned __base) {		_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_HIDE_FROM_ABI int
		__to_chars_integral_width(_Tp __value, unsigned __base) {
		QuuxplusoneUnsubmitted Done Reply Inline Actions Consider breaking after `int`, to match lines 308-309. Quuxplusone: Consider breaking after `int`, to match lines 308-309.
_LIBCPP_ASSERT(__value >= 0, "The function requires a non-negative value.");		_LIBCPP_ASSERT(__value >= 0, "The function requires a non-negative value.");

unsigned __base_2 = __base * __base;		unsigned __base_2 = __base * __base;
unsigned __base_3 = __base_2 * __base;		unsigned __base_3 = __base_2 * __base;
unsigned __base_4 = __base_2 * __base_2;		unsigned __base_4 = __base_2 * __base_2;

int __r = 0;		int __r = 0;
while (true) {		while (true) {
Show All 10 Lines	while (true) {
__r += 4;		__r += 4;
}		}

__libcpp_unreachable();		__libcpp_unreachable();
}		}

template <typename _Tp>		template <typename _Tp>
_LIBCPP_AVAILABILITY_TO_CHARS		_LIBCPP_AVAILABILITY_TO_CHARS
inline _LIBCPP_INLINE_VISIBILITY to_chars_result		inline _LIBCPP_HIDE_FROM_ABI to_chars_result
__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,		__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
false_type)		false_type)
{		{
if (__base == 10)		if (__base == 10)
return __to_chars_itoa(__first, __last, __value, false_type());		return __to_chars_itoa(__first, __last, __value, false_type());

ptrdiff_t __cap = __last - __first;		ptrdiff_t __cap = __last - __first;
int __n = __to_chars_integral_width(__value, __base);		int __n = __to_chars_integral_width(__value, __base);
if (__n > __cap)		if (__n > __cap)
return {__last, errc::value_too_large};		return {__last, errc::value_too_large};

__last = __first + __n;		__last = __first + __n;
char* __p = __last;		char* __p = __last;
do {		do {
unsigned __c = __value % __base;		unsigned __c = __value % __base;
__value /= __base;		__value /= __base;
*--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c];		*--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c];
} while (__value != 0);		} while (__value != 0);
return {__last, errc(0)};		return {__last, errc(0)};
}		}

template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>		template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
_LIBCPP_AVAILABILITY_TO_CHARS		_LIBCPP_AVAILABILITY_TO_CHARS
inline _LIBCPP_INLINE_VISIBILITY to_chars_result		inline _LIBCPP_HIDE_FROM_ABI to_chars_result
to_chars(char* __first, char* __last, _Tp __value)		to_chars(char* __first, char* __last, _Tp __value)
{		{
return __to_chars_itoa(__first, __last, __value, is_signed<_Tp>());		return __to_chars_itoa(__first, __last, __value, is_signed<_Tp>());
}		}

template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>		template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
_LIBCPP_AVAILABILITY_TO_CHARS		_LIBCPP_AVAILABILITY_TO_CHARS
inline _LIBCPP_INLINE_VISIBILITY to_chars_result		inline _LIBCPP_HIDE_FROM_ABI to_chars_result
to_chars(char* __first, char* __last, _Tp __value, int __base)		to_chars(char* __first, char* __last, _Tp __value, int __base)
{		{
_LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");		_LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
return __to_chars_integral(__first, __last, __value, __base,		return __to_chars_integral(__first, __last, __value, __base,
is_signed<_Tp>());		is_signed<_Tp>());
}		}

template <typename _It, typename _Tp, typename _Fn, typename... _Ts>		template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
inline _LIBCPP_INLINE_VISIBILITY from_chars_result		inline _LIBCPP_HIDE_FROM_ABI from_chars_result
__sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args)		__sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args)
{		{
using __tl = numeric_limits<_Tp>;		using __tl = numeric_limits<_Tp>;
decltype(__to_unsigned_like(__value)) __x;		decltype(__to_unsigned_like(__value)) __x;

bool __neg = (__first != __last && *__first == '-');		bool __neg = (__first != __last && *__first == '-');
auto __r = __f(__neg ? __first + 1 : __first, __last, __x, __args...);		auto __r = __f(__neg ? __first + 1 : __first, __last, __x, __args...);
switch (__r.ec)		switch (__r.ec)
{		{
case errc::invalid_argument:		case errc::invalid_argument:
return {__first, __r.ec};		return {__first, __r.ec};
case errc::result_out_of_range:		case errc::result_out_of_range:
return __r;		return __r;
default:		default:
break;		break;
}		}

if (__neg)		if (__neg)
{		{
if (__x <= __complement(__to_unsigned_like(__tl::min())))		if (__x <= __complement(__to_unsigned_like(__tl::min())))
{		{
__x = __complement(__x);		__x = __complement(__x);
_VSTD::memcpy(&__value, &__x, sizeof(__x));		std::memcpy(&__value, &__x, sizeof(__x));
return __r;		return __r;
}		}
}		}
else		else
{		{
if (__x <= __tl::max())		if (__x <= __tl::max())
{		{
__value = __x;		__value = __x;
return __r;		return __r;
}		}
}		}

return {__r.ptr, errc::result_out_of_range};		return {__r.ptr, errc::result_out_of_range};
}		}

template <typename _Tp>		template <typename _Tp>
inline _LIBCPP_INLINE_VISIBILITY bool		inline _LIBCPP_HIDE_FROM_ABI bool
__in_pattern(_Tp __c)		__in_pattern(_Tp __c)
{		{
return '0' <= __c && __c <= '9';		return '0' <= __c && __c <= '9';
}		}

struct _LIBCPP_HIDDEN __in_pattern_result		struct _LIBCPP_HIDDEN __in_pattern_result
{		{
bool __ok;		bool __ok;
int __val;		int __val;

explicit _LIBCPP_INLINE_VISIBILITY operator bool() const { return __ok; }		explicit _LIBCPP_HIDE_FROM_ABI operator bool() const { return __ok; }
};		};

template <typename _Tp>		template <typename _Tp>
inline _LIBCPP_INLINE_VISIBILITY __in_pattern_result		inline _LIBCPP_HIDE_FROM_ABI __in_pattern_result
__in_pattern(_Tp __c, int __base)		__in_pattern(_Tp __c, int __base)
{		{
if (__base <= 10)		if (__base <= 10)
return {'0' <= __c && __c < '0' + __base, __c - '0'};		return {'0' <= __c && __c < '0' + __base, __c - '0'};
else if (__in_pattern(__c))		else if (__in_pattern(__c))
return {true, __c - '0'};		return {true, __c - '0'};
else if ('a' <= __c && __c < 'a' + __base - 10)		else if ('a' <= __c && __c < 'a' + __base - 10)
return {true, __c - 'a' + 10};		return {true, __c - 'a' + 10};
else		else
return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10};		return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10};
}		}

template <typename _It, typename _Tp, typename _Fn, typename... _Ts>		template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
inline _LIBCPP_INLINE_VISIBILITY from_chars_result		inline _LIBCPP_HIDE_FROM_ABI from_chars_result
__subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f,		__subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f,
_Ts... __args)		_Ts... __args)
{		{
auto __find_non_zero = [](_It __first, _It __last) {		auto __find_non_zero = [](_It __first, _It __last) {
for (; __first != __last; ++__first)		for (; __first != __last; ++__first)
if (*__first != '0')		if (*__first != '0')
break;		break;
return __first;		return __first;
Show All 20 Lines	if (__r.ec == errc::result_out_of_range)
break;		break;
}		}
}		}

return __r;		return __r;
}		}

template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>		template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
inline _LIBCPP_INLINE_VISIBILITY from_chars_result		inline _LIBCPP_HIDE_FROM_ABI from_chars_result
__from_chars_atoi(const char* __first, const char* __last, _Tp& __value)		__from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
{		{
using __tx = __itoa::__traits<_Tp>;		using __tx = __itoa::__traits<_Tp>;
using __output_type = typename __tx::type;		using __output_type = typename __tx::type;

return __subject_seq_combinator(		return __subject_seq_combinator(
__first, __last, __value,		__first, __last, __value,
[](const char* __first, const char* __last,		[](const char* __first, const char* __last,
Show All 9 Lines	return __subject_seq_combinator(
return {__p, {}};		return {__p, {}};
}		}
}		}
return {__p, errc::result_out_of_range};		return {__p, errc::result_out_of_range};
});		});
}		}

template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>		template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
inline _LIBCPP_INLINE_VISIBILITY from_chars_result		inline _LIBCPP_HIDE_FROM_ABI from_chars_result
__from_chars_atoi(const char* __first, const char* __last, _Tp& __value)		__from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
{		{
using __t = decltype(__to_unsigned_like(__value));		using __t = decltype(__to_unsigned_like(__value));
return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);		return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);
}		}

template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>		template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
inline _LIBCPP_INLINE_VISIBILITY from_chars_result		inline _LIBCPP_HIDE_FROM_ABI from_chars_result
__from_chars_integral(const char* __first, const char* __last, _Tp& __value,		__from_chars_integral(const char* __first, const char* __last, _Tp& __value,
int __base)		int __base)
{		{
if (__base == 10)		if (__base == 10)
return __from_chars_atoi(__first, __last, __value);		return __from_chars_atoi(__first, __last, __value);

return __subject_seq_combinator(		return __subject_seq_combinator(
__first, __last, __value,		__first, __last, __value,
Show All 30 Lines	return __subject_seq_combinator(
}		}
}		}
return {__p, errc::result_out_of_range};		return {__p, errc::result_out_of_range};
},		},
__base);		__base);
}		}

template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>		template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
inline _LIBCPP_INLINE_VISIBILITY from_chars_result		inline _LIBCPP_HIDE_FROM_ABI from_chars_result
__from_chars_integral(const char* __first, const char* __last, _Tp& __value,		__from_chars_integral(const char* __first, const char* __last, _Tp& __value,
int __base)		int __base)
{		{
using __t = decltype(__to_unsigned_like(__value));		using __t = decltype(__to_unsigned_like(__value));
return __sign_combinator(__first, __last, __value,		return __sign_combinator(__first, __last, __value,
__from_chars_integral<__t>, __base);		__from_chars_integral<__t>, __base);
}		}

template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>		template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
inline _LIBCPP_INLINE_VISIBILITY from_chars_result		inline _LIBCPP_HIDE_FROM_ABI from_chars_result
from_chars(const char* __first, const char* __last, _Tp& __value)		from_chars(const char* __first, const char* __last, _Tp& __value)
{		{
return __from_chars_atoi(__first, __last, __value);		return __from_chars_atoi(__first, __last, __value);
}		}

template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>		template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
inline _LIBCPP_INLINE_VISIBILITY from_chars_result		inline _LIBCPP_HIDE_FROM_ABI from_chars_result
from_chars(const char* __first, const char* __last, _Tp& __value, int __base)		from_chars(const char* __first, const char* __last, _Tp& __value, int __base)
{		{
_LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");		_LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
return __from_chars_integral(__first, __last, __value, __base);		return __from_chars_integral(__first, __last, __value, __base);
}		}

// Floating-point implementation starts here.		// Floating-point implementation starts here.
// Unlike the other parts of charconv this is only available in C++17 and newer.		// Unlike the other parts of charconv this is only available in C++17 and newer.
Show All 37 Lines