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

[Mordante]

Summary

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

[philnik]

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.

[• Quuxplusone]

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.

[Mordante]

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.

[Mordante]

Address review comments.

libcxx/include/charconv

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_CXX03_LANG
+
 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* __u32toa(uint32_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;
 } // namespace __itoa
 
-#ifndef _LIBCPP_CXX03_LANG
-
 to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
 from_chars_result from_chars(const char*, const char*, bool, int = 10) = delete;
 
 namespace __itoa
 {
 
-static _LIBCPP_CONSTEXPR uint64_t __pow10_64[] = {
+static constexpr uint64_t __pow10_64[] = {
     UINT64_C(0),
     UINT64_C(10),
     UINT64_C(100),
     UINT64_C(1000),
     UINT64_C(10000),
     UINT64_C(100000),
     UINT64_C(1000000),
     UINT64_C(10000000),
     UINT64_C(100000000),
     UINT64_C(1000000000),
     UINT64_C(10000000000),
     UINT64_C(100000000000),
     UINT64_C(1000000000000),
     UINT64_C(10000000000000),
     UINT64_C(100000000000000),
     UINT64_C(1000000000000000),
     UINT64_C(10000000000000000),
     UINT64_C(100000000000000000),
     UINT64_C(1000000000000000000),
     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(1000),       UINT32_C(10000),    UINT32_C(100000),
     UINT32_C(1000000),    UINT32_C(10000000), UINT32_C(100000000),
     UINT32_C(1000000000),
 };
 
 template <typename _Tp, typename = void>
 struct _LIBCPP_HIDDEN __traits_base
 {
     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;
     }
 
     _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);
     }
 
-    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>
 struct _LIBCPP_HIDDEN
     __traits_base<_Tp, decltype(void(uint32_t{declval<_Tp>()}))>
 {
     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;
     }
 
     _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);
     }
 
-    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>
-inline _LIBCPP_INLINE_VISIBILITY bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 __mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r)
 {
     auto __c = __a * __b;
     __r = __c;
     return __c > numeric_limits<unsigned char>::max();
 }
 
 template <typename _Tp>
-inline _LIBCPP_INLINE_VISIBILITY bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 __mul_overflowed(unsigned short __a, _Tp __b, unsigned short& __r)
 {
     auto __c = __a * __b;
     __r = __c;
     return __c > numeric_limits<unsigned short>::max();
 }
 
 template <typename _Tp>
-inline _LIBCPP_INLINE_VISIBILITY bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 __mul_overflowed(_Tp __a, _Tp __b, _Tp& __r)
 {
     static_assert(is_unsigned<_Tp>::value, "");
 #if !defined(_LIBCPP_COMPILER_MSVC)
     return __builtin_mul_overflow(__a, __b, &__r);
 #else
     bool __did = __b && (numeric_limits<_Tp>::max() / __b) < __a;
     __r = __a * __b;
     return __did;
 #endif
 }
 
 template <typename _Tp, typename _Up>
-inline _LIBCPP_INLINE_VISIBILITY bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 __mul_overflowed(_Tp __a, _Up __b, _Tp& __r)
 {
     return __mul_overflowed(__a, static_cast<_Tp>(__b), __r);
 }
 
 template <typename _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 typename __traits_base<_Tp>::type;
 
     // 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)
     {
         type __cprod[digits];
         int __j = digits - 1;
         int __i = digits;
         do
         {
             if (!('0' <= *__p && *__p <= '9'))
                 break;
             __cprod[--__i] = *__p++ - '0';
         } while (__p != __ep && __i != 0);
 
         __a = __inner_product(__cprod + __i + 1, __cprod + __j, __pow() + 1,
                               __cprod[__i]);
         if (__mul_overflowed(__cprod[__j], __pow()[__j - __i], __b))
             --__p;
         return __p;
     }
 
     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)
     {
         for (; __first1 < __last1; ++__first1, ++__first2)
             __init = __init + *__first1 * *__first2;
         return __init;
     }
 };
 
 }  // namespace __itoa
 
 template <typename _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _Tp
+inline _LIBCPP_HIDE_FROM_ABI _Tp
 __complement(_Tp __x)
 {
     static_assert(is_unsigned<_Tp>::value, "cast to unsigned first");
     return _Tp(~__x + 1);
 }
 
 template <typename _Tp>
 _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)
 {
     auto __x = __to_unsigned_like(__value);
     if (__value < 0 && __first != __last)
     {
         *__first++ = '-';
         __x = __complement(__x);
     }
 
     return __to_chars_itoa(__first, __last, __x, false_type());
 }
 
 template <typename _Tp>
 _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)
 {
     using __tx = __itoa::__traits<_Tp>;
     auto __diff = __last - __first;
 
     if (__tx::digits <= __diff || __tx::__width(__value) <= __diff)
         return {__tx::__convert(__value, __first), errc(0)};
     else
         return {__last, errc::value_too_large};
 }
 
 template <typename _Tp>
 _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,
                     true_type)
 {
     auto __x = __to_unsigned_like(__value);
     if (__value < 0 && __first != __last)
     {
         *__first++ = '-';
         __x = __complement(__x);
     }
 
     return __to_chars_integral(__first, __last, __x, __base, false_type());
 }
 
 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) {
   _LIBCPP_ASSERT(__value >= 0, "The function requires a non-negative value.");
 
   unsigned __base_2 = __base * __base;
   unsigned __base_3 = __base_2 * __base;
   unsigned __base_4 = __base_2 * __base_2;
 
   int __r = 0;
   while (true) {
while (true) {
     __r += 4;
   }
 
   __libcpp_unreachable();
 }
 
 template <typename _Tp>
 _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,
                     false_type)
 {
   if (__base == 10)
     return __to_chars_itoa(__first, __last, __value, false_type());
 
   ptrdiff_t __cap = __last - __first;
   int __n = __to_chars_integral_width(__value, __base);
   if (__n > __cap)
     return {__last, errc::value_too_large};
 
   __last = __first + __n;
   char* __p = __last;
   do {
     unsigned __c = __value % __base;
     __value /= __base;
     *--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c];
   } while (__value != 0);
   return {__last, errc(0)};
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
 _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)
 {
     return __to_chars_itoa(__first, __last, __value, is_signed<_Tp>());
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
 _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)
 {
     _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
     return __to_chars_integral(__first, __last, __value, __base,
                                is_signed<_Tp>());
 }
 
 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)
 {
     using __tl = numeric_limits<_Tp>;
     decltype(__to_unsigned_like(__value)) __x;
 
     bool __neg = (__first != __last && *__first == '-');
     auto __r = __f(__neg ? __first + 1 : __first, __last, __x, __args...);
     switch (__r.ec)
     {
     case errc::invalid_argument:
         return {__first, __r.ec};
     case errc::result_out_of_range:
         return __r;
     default:
         break;
     }
 
     if (__neg)
     {
         if (__x <= __complement(__to_unsigned_like(__tl::min())))
         {
             __x = __complement(__x);
-            _VSTD::memcpy(&__value, &__x, sizeof(__x));
+            std::memcpy(&__value, &__x, sizeof(__x));
             return __r;
         }
     }
     else
     {
         if (__x <= __tl::max())
         {
             __value = __x;
             return __r;
         }
     }
 
     return {__r.ptr, errc::result_out_of_range};
 }
 
 template <typename _Tp>
-inline _LIBCPP_INLINE_VISIBILITY bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 __in_pattern(_Tp __c)
 {
     return '0' <= __c && __c <= '9';
 }
 
 struct _LIBCPP_HIDDEN __in_pattern_result
 {
     bool __ok;
     int __val;
 
-    explicit _LIBCPP_INLINE_VISIBILITY operator bool() const { return __ok; }
+    explicit _LIBCPP_HIDE_FROM_ABI operator bool() const { return __ok; }
 };
 
 template <typename _Tp>
-inline _LIBCPP_INLINE_VISIBILITY __in_pattern_result
+inline _LIBCPP_HIDE_FROM_ABI __in_pattern_result
 __in_pattern(_Tp __c, int __base)
 {
     if (__base <= 10)
         return {'0' <= __c && __c < '0' + __base, __c - '0'};
     else if (__in_pattern(__c))
         return {true, __c - '0'};
     else if ('a' <= __c && __c < 'a' + __base - 10)
         return {true, __c - 'a' + 10};
     else
         return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10};
 }
 
 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,
                          _Ts... __args)
 {
     auto __find_non_zero = [](_It __first, _It __last) {
         for (; __first != __last; ++__first)
             if (*__first != '0')
                 break;
         return __first;
if (__r.ec == errc::result_out_of_range)
                 break;
         }
     }
 
     return __r;
 }
 
 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)
 {
     using __tx = __itoa::__traits<_Tp>;
     using __output_type = typename __tx::type;
 
     return __subject_seq_combinator(
         __first, __last, __value,
         [](const char* __first, const char* __last,
return __subject_seq_combinator(
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};
         });
 }
 
 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)
 {
     using __t = decltype(__to_unsigned_like(__value));
     return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);
 }
 
 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,
                       int __base)
 {
     if (__base == 10)
         return __from_chars_atoi(__first, __last, __value);
 
     return __subject_seq_combinator(
         __first, __last, __value,
return __subject_seq_combinator(
                 }
             }
             return {__p, errc::result_out_of_range};
         },
         __base);
 }
 
 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,
                       int __base)
 {
     using __t = decltype(__to_unsigned_like(__value));
     return __sign_combinator(__first, __last, __value,
                              __from_chars_integral<__t>, __base);
 }
 
 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)
 {
     return __from_chars_atoi(__first, __last, __value);
 }
 
 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)
 {
     _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
     return __from_chars_integral(__first, __last, __value, __base);
 }
 
 // Floating-point implementation starts here.
 // Unlike the other parts of charconv this is only available in C++17 and newer.