[libc++] Include C++ headers, not C headers, in <charconv>

[• Quuxplusone]

Summary

This matches how libc++ does it in all other C++ headers (that is, headers not ending in ".h").
We need to include <cstring> if we want to use _VSTD::memmove instead of unqualified ADL memmove. Even though ADL doesn't physically matter in <charconv>'s specific case, I'm trying to migrate libc++ to using _VSTD::memmove for all cases (because some of them do matter, and this way it's easier to grep for outliers).

[• Quuxplusone]

libcxx/include/charconv

429

For the record: It might be nice if all of these function calls were also _VSTD-ed, but I decided that I didn't want to be that invasive right now. I am 99% confident that none of these function calls (including the memmove/memcpy ones that I am changing) can possibly be hijacked by ADL, because to_chars and from_chars are not templates and therefore no user-defined or even non-primitive types can possibly leak into these codepaths which are reachable only via the "bottleneck" of those non-template functions.

libcxx/include/charconv

 
 } // namespace std
 
 */
 
 #include <__config>
 #include <__availability>
 #include <__errc>
-#include <type_traits>
+#include <cmath> // for log2f
+#include <cstdint>
+#include <cstring>
 #include <limits>
-#include <stdint.h>
-#include <string.h>
-#include <math.h>
+#include <type_traits>
 
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
if (__tx::digits <= __diff)
         return {__tx::__convert(__value, __first), {}};
     else
     {
         char __buf[__tx::digits];
         auto __p = __tx::__convert(__value, __buf);
         auto __len = __p - __buf;
         if (__len <= __diff)
         {
-            memcpy(__first, __buf, __len);
+            _VSTD::memcpy(__first, __buf, __len);
             return {__first + __len, {}};
         }
         else
             return {__last, errc::value_too_large};
     }
 #endif
 }
 
while (__p != __first)
             break;
     }
 
     auto __len = __last - __p;
     if (__value != 0 || !__len)
         return {__last, errc::value_too_large};
     else
     {
-        memmove(__first, __p, __len);
+        _VSTD::memmove(__first, __p, __len);
         return {__first + __len, {}};
     }
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
 _LIBCPP_AVAILABILITY_TO_CHARS
 inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 to_chars(char* __first, char* __last, _Tp __value)
__sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args)
     case errc::result_out_of_range:
         return __r;
     default:
         break;
     }
 
     if (__neg)
     {
         if (__x <= __complement(__to_unsigned(__tl::min())))
         {
             __x = __complement(__x);
-            memcpy(&__value, &__x, sizeof(__x));
+            _VSTD::memcpy(&__value, &__x, sizeof(__x));
             return __r;
         }
     }
     else
     {
         if (__x <= __tl::max())
         {
             __value = __x;