Make the `<charconv>` header usable with C++11

[mclow.lists]

Summary

We already support to_chars and from_chars back to C++14.
Tweak the code so that we can use it from C++11.

The motivation for this is D59178.
I really don't want *another* "integer to string" implementation in libc++.

[lichray]

libcxx/test/support/charconv_test_helpers.h

125

Using auto here is fine.

134

Ditto.

[ldionne]

This is one acceptable reason to backport functionality to C++03 IMO. I'd rather have it be implementation details using reserved names, but this would add a lot of complexity.

[mclow.lists]

In D59598#1436484, @ldionne wrote:

This is one acceptable reason to backport functionality to C++03 IMO. I'd rather have it be implementation details using reserved names, but this would add a lot of complexity.

I'm not going back to C++03 here. Just C++11.

[ldionne]

In D59598#1436564, @mclow.lists wrote:

In D59598#1436484, @ldionne wrote:

This is one acceptable reason to backport functionality to C++03 IMO. I'd rather have it be implementation details using reserved names, but this would add a lot of complexity.

I'm not going back to C++03 here. Just C++11.

Yeah, I don't know why I said that. But you get the point -- I'm talking about back porting at all, which I dislike.

[mclow.lists]

I landed this already. Closing.

libcxx/include/charconv

 _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer);
 }
 
-#if _LIBCPP_STD_VER > 11
+#ifndef _LIBCPP_CXX03_LANG
 
 enum class _LIBCPP_ENUM_VIS chars_format
 {

 namespace __itoa
 {
 
-static constexpr uint64_t __pow10_64[] = {
+static _LIBCPP_CONSTEXPR uint64_t __pow10_64[] = {
     UINT64_C(0),
     UINT64_C(10),
     UINT64_C(100),

     UINT64_C(10000000000000000000),
 };
 
-static constexpr uint32_t __pow10_32[] = {
+static _LIBCPP_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),

         return __u64toa(__v, __p);
     }
 
-    static _LIBCPP_INLINE_VISIBILITY auto& __pow() { return __pow10_64; }
+    static _LIBCPP_INLINE_VISIBILITY decltype(__pow10_64)& __pow() { return __pow10_64; }
 };
 
 template <typename _Tp>

         return __u32toa(__v, __p);
     }
 
-    static _LIBCPP_INLINE_VISIBILITY auto& __pow() { return __pow10_32; }
+    static _LIBCPP_INLINE_VISIBILITY decltype(__pow10_32)& __pow() { return __pow10_32; }
 };
 
 template <typename _Tp>

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

 }
 
 template <typename _Tp>
-inline _LIBCPP_INLINE_VISIBILITY auto
+inline _LIBCPP_INLINE_VISIBILITY typename make_unsigned<_Tp>::type
 __to_unsigned(_Tp __x)
 {
-    return static_cast<make_unsigned_t<_Tp>>(__x);
+    return static_cast<typename make_unsigned<_Tp>::type>(__x);
 }
 
 template <typename _Tp>

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

     return __r;
 }
 
-template <typename _Tp, enable_if_t<is_unsigned<_Tp>::value, int> = 0>
+template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {

         });
 }
 
-template <typename _Tp, enable_if_t<is_signed<_Tp>::value, int> = 0>
+template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {

     return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);
 }
 
-template <typename _Tp, enable_if_t<is_unsigned<_Tp>::value, int> = 0>
+template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)

         __base);
 }
 
-template <typename _Tp, enable_if_t<is_signed<_Tp>::value, int> = 0>
+template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)

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

     return __from_chars_integral(__first, __last, __value, __base);
 }
 
-#endif  // _LIBCPP_STD_VER > 11
+#endif  // _LIBCPP_CXX03_LANG
 
 _LIBCPP_END_NAMESPACE_STD
 

libcxx/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, c++11
+// UNSUPPORTED: c++98, c++03
 // <charconv>
 
 // In

libcxx/test/std/utilities/charconv/charconv.from.chars/integral.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, c++11
+// UNSUPPORTED: c++98, c++03
 
 // XFAIL: with_system_cxx_lib=macosx10.14
 // XFAIL: with_system_cxx_lib=macosx10.13

libcxx/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, c++11
+// UNSUPPORTED: c++98, c++03
 // <charconv>
 
 // In

libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp

 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, c++11
+// UNSUPPORTED: c++98, c++03
 
 // XFAIL: with_system_cxx_lib=macosx10.14
 // XFAIL: with_system_cxx_lib=macosx10.13

libcxx/test/support/charconv_test_helpers.h

 
 #include "test_macros.h"
 
-#if TEST_STD_VER <= 11
-#error This file requires C++14
+#if TEST_STD_VER < 11
+#error This file requires C++11
 #endif
 
 using std::false_type;

 constexpr bool
 _fits_in(T v, false_type, true_type /* T signed */, false_type /* X unsigned*/)
 {
-    return 0 <= v && std::make_unsigned_t<T>(v) <= (xl::max)();
+    return 0 <= v && typename std::make_unsigned<T>::type(v) <= (xl::max)();
 }
 
 template <typename X, typename T, typename xl = std::numeric_limits<X>>
 constexpr bool
 _fits_in(T v, false_type, false_type /* T unsigned */, ...)
 {
-    return v <= std::make_unsigned_t<X>((xl::max)());
+    return v <= typename std::make_unsigned<X>::type((xl::max)());
 }
 
 template <typename X, typename T>

     }
 
 private:
-    static auto fromchars(char const* p, char const* ep, int base, true_type)
+    static long long fromchars(char const* p, char const* ep, int base, true_type)
     {
         char* last;
-        auto r = strtoll(p, &last, base);
+        long long r = strtoll(p, &last, base);
         assert(last == ep);
 
         return r;
     }
 
-    static auto fromchars(char const* p, char const* ep, int base, false_type)
+    static unsigned long long fromchars(char const* p, char const* ep, int base, false_type)
     {
         char* last;
-        auto r = strtoull(p, &last, base);
+        unsigned long long r = strtoull(p, &last, base);
         assert(last == ep);
 
         return r;
     }
 
     static auto fromchars(char const* p, char const* ep, int base = 10)
+    -> decltype(fromchars(p, ep, base, std::is_signed<X>()))
     {
         return fromchars(p, ep, base, std::is_signed<X>());
     }