[libc++][C++17] Elementary string conversions for integral types

[lichray]

Summary

Major QoI considerations:

• The facility is backported to C++14, same as libstdc++.
• Efforts have been made to minimize the header dependencies.
• The design is friendly to the uses of MSVC intrinsics (__emulu, _umul128, _BitScanForward, _BitScanForward64) but not implemented; future contributions are welcome.

Thanks to Milo Yip for contributing the implementation of __u64toa and __u32toa.

References:
https://wg21.link/p0067r5
https://wg21.link/p0682r1

[mclow.lists]

I've got an implementation for this, too - at https://github.com/mclow/snippets/blob/master/to_chars.cpp

I'll compare them.

[lichray]

Added std::from_chars

[lichray]

Use Marshall's method to generate digits in reversed order in generic to_chars.

[lichray]

Just include math.h

[lichray]

src/support/itoa/itoa.cpp in previous diffs were copyrighted by Tencent, now LLVM, contributed by the same author.

[EricWF]

Some initial thoughts.

@mclow.lists Are you planning on moving forward with your implementation as well?

include/charconv

90

We need to hide these names when _LIBCPP_STD_VER < 17, since we're not allowed to introduce new names into namespace std in older dialects.

91

enum types should have their underlying integer type explicitly specified. Otherwise their size and ABI can break when users specify -short-enums

115

No reason for using trailing return type syntax here.

123

Same as above. There's no reason to deviate from the typical libc++ style and use trailing return types here.

152

<algorithm> already has a __clz wrapper for __builtin_clz et al. We should use that instead. That also allows us to get rid of the fallback implementation, and it correctly uses the builtin for compilers like GCC which don't provide __has_builtin.

include/support/itoa/itoa.h

2

I would rather not introduce another header for this. I think it should go directly in the charconv header.

25

I'm not sure I love having static globals in the headers, but I can't think of a better way to write this.

30

The UINT64_C and UINT32_C macros are non-standard, so I would rather not use them in a header.

Additionally, the compiler should correctly convert the integer type to the array's element type, no?

48

I suspect we can use __pow10_64 in the 32 bit case as well to avoid emitting another static global.

55

Use __clz from <algorithm>. You can assume we always have that.

58

__u64digits10 and __u32digits10 can be folded into width, since it's the only caller.

73

We don't marke functions in the dylib with extern.

77

Maybe a more descriptive name than __traits?

82

width, convert and pow need to be reserved names.

124

__builtin_mul_overflow works for char and short, so can't we just call that?

145

GCC provides these builtins but __has_builtin won't detect them.

We can probably safely assume that every compiler except _LIBCPP_COMPILER_MSVC provides them, and only work around MSVC.

162

traits needs to be a reserved name, and preferably a more descriptive one.

189

What's wrong with using std::inner_product?

src/support/itoa/itoa.cpp

2

This file should be renamed charconv.cpp and moved into the main source directory.

20

This should be constexpr to ensure correct initialization.

36

Any reason these can't be static functions? The compiler should optimize them away nicely.

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

57

LIBCPP_ASSERT is only intended to test non-standard behavior that libc++ happens to have but that isn't required by the standard.

If this behavior is specified by the standard it should be tested using assert instead.

[EricWF]

@lichray I should have mentioned: Although this header is C++17 only, the bits compiled into the dylib need to compile as C++11 still.

[lichray]

I will pick up the changes later next week.

include/charconv

90

But this header is backported to C++11, so I intended to not to guard it.

123

libc++ doesn't have one uniformed style. For some reason I found this style formats better with clang-format.

152

I saw that, and I agree this can be improved, however <algorithm> would be too heavy to include here. Thoughts?

include/support/itoa/itoa.h

82

These names are standard names (functions), so users can't provide function style macros to override them. Am I wrong on that?

124

I don't think so, it "works" after promotion.

162

Similarly It's a standard name (std::string typedef), so user can't use a non-function style macro name to override it, IIUC.

189

__first != __last1 instead of <

src/support/itoa/itoa.cpp

2

We are going to have floating point cpp files so I don't think that one charconv.cpp is enough.

36

Although yes, but that's what the author provides. It's an implementation file, so it doesn't matter I guess.

[lichray]

Pending patch update due to poor network.

include/charconv

91

The standard requires enum class to default to int; IIUC enum class is not affected by -fshort-enums.

include/support/itoa/itoa.h

2

We may have separated floating point headers coming as well...

48

I have functions returning them as array references.

55

Factor __clz out of algorithm may be too much for this review. I would like to see a subsequent patch to take care of all the related portability fixes.

[lichray]

include/support/itoa/itoa.h

30

They are from C standard, and I included the corresponding C header. Dropping them gave me -Wimplicitly-unsigned-literal warning.

[lichray]

Addressing 'Done' comments

[lichray]

Keep patches split

[mclow.lists]

Sorry I've let this lie fallow for so long.

include/charconv

235

Why use the trailing return type here?
I don't see any advantage - it doesn't depend on the parameters (template or runtime).

src/support/itoa/itoa.cpp

2

We can put both integral and floating point routines in the same source file ;-)

What Eric said - there should be just charconv.cpp, and no subdirectory.

Also, if this is not your work, then I need some notice (an email is fine) by the author saying that they're OK with contributing this under the LLVM license.

36

It *does* matter, since we'll have to maintain this.

It would also be nice if they had meaningful names.

[lichray]

include/charconv

235

Because clang-format doesn't distinguish storage specifiers and simple-type-specifiers, and I want to format return types along with function signatures rather than letting hanging somewhere.

src/support/itoa/itoa.cpp

36

I tried (template + forceinline), and the binary was optimized differently (emitted ~100 more instructions). The author have tuned these really well. A syntax like buffer = append1(buffer, v) may work better, I guess, but that adds lots of noises.

These macros are not complex. They just emit a integer of width 1234 to digits.

[lichray]

Reorganize files

[lichray]

Update module map

[mclow.lists]

include/charconv

90

But this header is backported to C++11, so I intended to not to guard it.

In general, we don't provide new features for old language versions.

The only time we've ever done that is for string_view, and I'm still not sure I did the right thing there.

src/charconv.cpp

34 ↗

(On Diff #141110)

I'd really like to see some numbers here showing how this (somewhat awkward) code performs better than the straightforward versions.

Because maintenance is forever.

Note: I'm sure that this was true on older compilers - but is it true today?

test/support/charconv_test_helpers.h

25

If this is supposed to be a C++17 or later header (and I'm pretty sure it is), you should add a static_assert(TEST_STD_VER > 14, ""); to this header.

[lichray]

include/charconv

90

We need to decide on this... From my point of view this header will be widely used by formatting and logging libraries, and it doesn't add much to the community by enforcing C++17 here, especially when the interface we specified are very simple and not using any features beyond C++11.

src/charconv.cpp

34 ↗

(On Diff #141110)

One thing I could try may be using return values rather than output parameters, like

buffer = append3(buffer, b);

But I really don't think doing these makes the code any bit more maintainable comparing to

APPEND3(b);

, which looks very straightforward and expressive to me...

[• Quuxplusone]

include/charconv

90

This question is also relevant to my interests, in re <memory_resource>.

[lichray]

A macro-free implementation

[lichray]

src/charconv.cpp

34 ↗

(On Diff #141110)

OK, after several attempts, I figured out that by eliminating side-effects to the buffer pointer in the helper functions, Clang now generates code of the same quality, and runs statistically faster.

[lichray]

Install the header file

[lichray]

test/support/charconv_test_helpers.h

25

I can run it with --param=std=c++11.

[mclow.lists]

.gitignore

7

I'm pretty sure this file doesn't belong in this diff.

include/charconv

90

From my point of view this header will be widely used by formatting and logging libraries,

Non-portable formatting and logging libraries - if we provide it before C++17 and they use it.

152

We could make this depend on <bit> once P0553 is adopted. (use countl_zero)

My intention there is to provide __countl_zero etc for internal use before C++20, and the public names for C++20 and later. That approach could be used here as well, if we choose.

235

That's an argument for fixing clang-format, not for writing the code this way.

241

I'm pretty sure we can't declare a type named traits - even inside a namespace.

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

134

Rather than attempting to reuse bits of the string here, I would define a struct:

struct test_data {
    const char *input;
    const char *output;
    std::errc err;
    T value;
    };

and then write a bunch of test cases and iterate over them.

[lichray]

include/charconv

90

When they use it, what's next?

1. Someone try to use the library against libstdc++, he/she
   • file a bug report to the library, or
   • file a bug report to libstdc++
2. The library has too little users, so it's okay for it to be non-portable.

Looks good to me.

152

OK.

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

134

No longer reusing parts from the string.

[lichray]

Respond to the 2nd round review

[lichray]

Less trailing return types

[lichray]

include/charconv

235

Yes... I did some research on ClangFormat, until... Anyway, I moved most of the trailing return types to the front, leaving two which are too complex in the header, and a few necessary ones in the tests.

[lichray]

Dropping C++11 support.

[lichray]

include/charconv

90

Back-ported to C++14, in-line with libstdc++.

[mclow.lists]

include/charconv

373

Are you missing an edge case here? What happens if __last == __first && __value == 0?

test/support/charconv_test_helpers.h

41

We don't need to use ugly names here in the test suite.

[mclow.lists]

include/charconv

245

Same comment as above about read and inner_product - they need to be "ugly names"

359

I just want you to reassure me here - this lambda gets inlined, right?

[mclow.lists]

include/charconv

360

Thinking some more - did this used to do more? Because I don't see why having a lambda here is a benefit, as compared to:

const char *__digits = "0123456789abcdefghijklmnopqrstuvwxyz";

and

*--p = digits[__c];

[lichray]

include/charconv

245

Unlike traits which is a template parameter name in the standard, read and inner_product are function names in the standard, which means the users cannot make a macro for them (and there is no guarantee about what name you make not get by including certain headers), so we don't need to use ugly names here, am I right?

359

Yes -- I read my code in assembly.

360

I use a lambda here because it may do more in the future. If someone wants to let it support non-ASCII platforms, then they only need to make a patch against this lambda rather than changing the sites of uses. After all, there is nothing wrong to abstract out anything into a function, I think...

[mclow.lists]

include/charconv

373

Nevermind. Apparently I can't look two lines down.

[mclow.lists]

include/charconv

245

I understand your reasoning, but I don't agree.

Just last month, I had to rename a function in vector from allocate to __vallocate because it confused our "is this an allocator" detection. The function in question was private, so it shouldn't have mattered, but GCC has a bug where sometimes it partially ignores access restrictions in non-deduced contexts, and then throws a hard error when it comes back to a different context. The easiest workaround was to rename the function in vector.

Since then, I've been leery of public names that match others. This is pretty obscure, since it's in a private namespace, but I'd feel better if they were __read and __inner_product.

[• Quuxplusone]

include/charconv

245

FWIW, +1 to ugly names. Even if the un-ugly code is "technically not broken yet", and besides the technical reason Marshall gives,
(1) it's nice that libc++ has style rules and sticks to them, precisely to *avoid* bikeshedding the name of every private member in the world;
(2) just because users can't #define read write doesn't mean they *won't* do it. I would actually be extremely surprised if read were *not* defined as a macro somewhere inside <windows.h>. :)

See also: "should this function call be _VSTD::-qualified?" Sometimes the answer is technically "no", but stylistically "yes", precisely to indicate that we *don't* intend for it to be an ADL customization point. Consistent style leads to maintainability.

[lichray]

Uglify all the names

[lichray]

include/charconv

245

read is a function decl in <io.h>, not redefined in other forms in <windows.h>.

test/support/charconv_test_helpers.h

41

Err, it's not? Just an impl version of fits_in (without the _ prefix).

[lichray]

Ping. Any more comments?

[mclow.lists]

Getting close here. I'll have a couple more comments later today, so don't post a new diff quite yet.

include/charconv

159

In general, we don't put _LIBCPP_COMPILER_XXX in header files in libc++.
Instead, we declare a feature macro _LIBCPP_HAS_XXXX in <__config> and then use that everywhere.

I see that most of the uses of _LIBCPP_COMPILER_MSVC are in <algorithm>, and center around the builtins for __builtin_clz, etc.

We can clean this up later. (/me makes note).

245

See also: "should this function call be _VSTD::-qualified

We already have an inner_product ( in <algorithm>), so I think not.

We _VSTD:: qualify move and forward always. min/max due mostly to windows macros. swap when need to disable ADL.

Other things we're inconsistent about: declval sometimes (I don't know why), use_facet, addressof, to_raw_pointer.

I'll figure out when we should mark things with _VSTD and write it up.

286

in libc++, we put the return type on the left.

template <typename _Tp>
inline _LIBCPP_INLINE_VISIBILITY
auto __to_unsigned(_Tp __x)

(and then ask 'why auto'?)

360

I don't think that making it a lambda today buys us anything. Since it is local, we can make it a lambda again in the future if we need to w/o breaking anyone.

Shades of YAGNI.

test/support/charconv_test_helpers.h

227

This name run concerns me. I'd feel better if it was run_integral_tests or something a bit less general.

On the other hand, it's in a test, so we can change it whenever we want.

[lichray]

include/charconv

159

MSVC has the intrinsics we need, but I did not plan to put too much in this patch. The suggested <bits> header sounds like a good place for grouping up those intrinsics in the future.

286

template <typename _Tp>
inline _LIBCPP_INLINE_VISIBILITY
auto __to_unsigned(_Tp __x)

I want this as well, but ClangFormat doesn't support it... The style which I'm using is close to FreeBSD style(9), please forgive. I don't mind if you send me a .clang-format file (the one I used is http://paste.openstack.org/show/726883/), but I won't manually adjust the code...

About why auto -- this file requires C++14 already, so I don't need to repeat my self (by writing make_unsigned_t<_Tp> again).

test/support/charconv_test_helpers.h

227

The callsites look like

run<test_signed>(all_signed);

That's why I named it "run". Not an issue for now I think.

[• Quuxplusone]

@lichray: I'm interested in merging this patch into my libc++ fork, but the latest update seems to be missing a ton of files. For example charconv_test_helpers.h is included by one of the tests, but does not exist. Also there's a lot of boilerplate missing: you ought to add the new header to module.modulemap, and to double_include.sh.cpp, and so on. Might you upload a new patch anytime soon?

EDIT: Weird, the diff is different now. Must have been some kind of race condition. Nvm.

[lichray]

Dropping a lambda

[mclow.lists]

LGTM. Thanks!

.gitignore

 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
 
 # C extensions
 *.so
+*.core
+
+# Vim
+*~
+.*.swp
 
 # Distribution / packaging
 .Python
 env/
 build/
 develop-eggs/
 dist/
 downloads/

include/charconv

+// -*- C++ -*-
+//===------------------------------ charconv ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_CHARCONV
+#define _LIBCPP_CHARCONV
+
+/*
+    charconv synopsis
+
+namespace std {
+
+  // floating-point format for primitive numerical conversion
+  enum class chars_format {
+    scientific = unspecified,
+    fixed = unspecified,
+    hex = unspecified,
+    general = fixed | scientific
+  };
+
+  // 23.20.2, primitive numerical output conversion
+  struct to_chars_result {
+    char* ptr;
+    errc ec;
+  };
+
+  to_chars_result to_chars(char* first, char* last, see below value,
+                           int base = 10);
+
+  to_chars_result to_chars(char* first, char* last, float value);
+  to_chars_result to_chars(char* first, char* last, double value);
+  to_chars_result to_chars(char* first, char* last, long double value);
+
+  to_chars_result to_chars(char* first, char* last, float value,
+                           chars_format fmt);
+  to_chars_result to_chars(char* first, char* last, double value,
+                           chars_format fmt);
+  to_chars_result to_chars(char* first, char* last, long double value,
+                           chars_format fmt);
+
+  to_chars_result to_chars(char* first, char* last, float value,
+                           chars_format fmt, int precision);
+  to_chars_result to_chars(char* first, char* last, double value,
+                           chars_format fmt, int precision);
+  to_chars_result to_chars(char* first, char* last, long double value,
+                           chars_format fmt, int precision);
+
+  // 23.20.3, primitive numerical input conversion
+  struct from_chars_result {
+    const char* ptr;
+    errc ec;
+  };
+
+  from_chars_result from_chars(const char* first, const char* last,
+                               see below& value, int base = 10);
+
+  from_chars_result from_chars(const char* first, const char* last,
+                               float& value,
+                               chars_format fmt = chars_format::general);
+  from_chars_result from_chars(const char* first, const char* last,
+                               double& value,
+                               chars_format fmt = chars_format::general);
+  from_chars_result from_chars(const char* first, const char* last,
+                               long double& value,
+                               chars_format fmt = chars_format::general);
+
+} // namespace std
+
+*/
+
+#include <__errc>
+#include <support/itoa/itoa.h>
+#include <string.h>
+
+#include <__debug>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+extern "C" float log2f(float);
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+enum class _LIBCPP_ENUM_VIS chars_format
+{
+    scientific = 0x1,
+    fixed = 0x2,
+    hex = 0x4,
+    general = fixed | scientific
+};
+
+struct _LIBCPP_TYPE_VIS to_chars_result
+{
+    char* ptr;
+    errc ec;
+};
+
+struct _LIBCPP_TYPE_VIS from_chars_result
+{
+    const char* ptr;
+    errc ec;
+};
+
+void to_chars(char*, char*, bool, int = 10) = delete;
+void from_chars(const char*, const char*, bool, int = 10) = delete;
+
+template <typename _Tp>
+inline _LIBCPP_INLINE_VISIBILITY auto
+__complement(_Tp __x) -> _Tp
+{
+    static_assert(is_unsigned<_Tp>::value, "cast to unsigned first");
+    return _Tp(~__x + 1);
+}
+
+template <typename _Tp>
+inline _LIBCPP_INLINE_VISIBILITY auto
+__to_unsigned(_Tp __x) -> typename make_unsigned<_Tp>::type
+{
+    return static_cast<typename make_unsigned<_Tp>::type>(__x);
+}
+
+template <typename _Tp>
+inline _LIBCPP_INLINE_VISIBILITY auto
+__to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)
+    -> to_chars_result
+{
+    auto __x = __to_unsigned(__value);
+    if (__value < 0 && __first != __last)
+    {
+        *__first++ = '-';
+        __x = __complement(__x);
+    }
+
+    return __to_chars_itoa(__first, __last, __x, false_type());
+}
+
+template <typename _Tp>
+inline _LIBCPP_INLINE_VISIBILITY auto
+__to_chars_itoa(char* __first, char* __last, _Tp __value, false_type)
+    -> to_chars_result
+{
+    using __tx = __itoa::traits<_Tp>;
+    auto __diff = __last - __first;
+
+#if __has_builtin(__builtin_clzll)
+    if (__tx::digits <= __diff || __tx::width(__value) <= __diff)
+        return {__tx::convert(__value, __first), {}};
+    else
+        return {__last, errc::value_too_large};
+#else
+    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);
+            return {__first + __len, {}};
+        }
+        else
+            return {__last, errc::value_too_large};
+    }
+#endif
+}
+
+template <typename _Tp>
+inline _LIBCPP_INLINE_VISIBILITY auto
+__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
+                    true_type) -> to_chars_result
+{
+    auto __x = __to_unsigned(__value);
+    if (__value < 0 && __first != __last)
+    {
+        *__first++ = '-';
+        __x = __complement(__x);
+    }
+
+    return __to_chars_integral(__first, __last, __x, __base, false_type());
+}
+
+template <typename _Tp>
+inline _LIBCPP_INLINE_VISIBILITY auto
+__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
+                    false_type) -> to_chars_result
+{
+    if (__base == 10)
+        return __to_chars_itoa(__first, __last, __value, false_type());
+
+    auto __gen_digit = [](_Tp __c) {
+        return "0123456789abcdefghijklmnopqrstuvwxyz"[__c];
+    };
+
+    auto __p = __last;
+    while (__p != __first)
+    {
+        auto __c = __value % __base;
+        __value /= __base;
+        *--__p = __gen_digit(__c);
+        if (__value == 0)
+            break;
+    }
+
+    auto __len = __last - __p;
+    if (__value != 0 || !__len)
+        return {__last, errc::value_too_large};
+    else
+    {
+        memmove(__first, __p, __len);
+        return {__first + __len, {}};
+    }
+}
+
+template <typename _Tp,
+          typename enable_if<is_integral<_Tp>::value, int>::type = 0>
+inline _LIBCPP_INLINE_VISIBILITY auto
+to_chars(char* __first, char* __last, _Tp __value) -> to_chars_result
+{
+    return __to_chars_itoa(__first, __last, __value, is_signed<_Tp>());
+}
+
+template <typename _Tp,
+          typename enable_if<is_integral<_Tp>::value, int>::type = 0>
+inline _LIBCPP_INLINE_VISIBILITY auto
+to_chars(char* __first, char* __last, _Tp __value, int __base)
+    -> to_chars_result
+{
+    _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 auto
+__sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args)
+    -> from_chars_result
+{
+    using __tl = numeric_limits<_Tp>;
+    decltype(__to_unsigned(__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(__tl::min())))
+        {
+            __x = __complement(__x);
+            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 auto
+__in_pattern(_Tp __c) -> bool
+{
+    return '0' <= __c && __c <= '9';
+}
+
+struct _LIBCPP_HIDDEN __in_pattern_result
+{
+    bool __ok;
+    int __val;
+
+    explicit _LIBCPP_ALWAYS_INLINE operator bool() const { return __ok; }
+};
+
+template <typename _Tp>
+inline _LIBCPP_INLINE_VISIBILITY auto
+__in_pattern(_Tp __c, int __base) -> __in_pattern_result
+{
+    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 auto
+__subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f,
+                         _Ts... __args) -> from_chars_result
+{
+    auto __find_non_zero = [](_It __first, _It __last) -> _It {
+        for (; __first != __last; ++__first)
+            if (*__first != '0')
+                break;
+        return __first;
+    };
+
+    auto __p = __find_non_zero(__first, __last);
+    if (__p == __last || !__in_pattern(*__p, __args...))
+    {
+        if (__p == __first)
+            return {__first, errc::invalid_argument};
+        else
+        {
+            __value = 0;
+            return {__p, {}};
+        }
+    }
+
+    auto __r = __f(__p, __last, __value, __args...);
+    // ...you just can't let them approve anything that wasn't implemented
+    if (__r.ec == errc::result_out_of_range)
+    {
+        for (; __r.ptr != __last; ++__r.ptr)
+        {
+            if (!__in_pattern(*__r.ptr, __args...))
+                break;
+        }
+    }
+
+    return __r;
+}
+
+template <typename _Tp,
+          typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
+inline _LIBCPP_INLINE_VISIBILITY auto
+__from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
+    -> from_chars_result
+{
+    using __tx = __itoa::traits<_Tp>;
+    using __output_type = typename __tx::type;
+
+    return __subject_seq_combinator(
+        __first, __last, __value,
+        [](const char* __first, const char* __last,
+           _Tp& __value) -> from_chars_result {
+            __output_type __a, __b;
+            auto __p = __tx::read(__first, __last, __a, __b);
+            if (__p == __last || !__in_pattern(*__p))
+            {
+                __output_type __m = (numeric_limits<_Tp>::max)();
+                if (__m >= __a && __m - __a >= __b)
+                {
+                    __value = __a + __b;
+                    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 auto
+__from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
+    -> from_chars_result
+{
+    using __t = decltype(__to_unsigned(__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 auto
+__from_chars_integral(const char* __first, const char* __last, _Tp& __value,
+                      int __base) -> from_chars_result
+{
+    if (__base == 10)
+        return __from_chars_atoi(__first, __last, __value);
+
+    return __subject_seq_combinator(
+        __first, __last, __value,
+        [](const char* __p, const char* __last, _Tp& __value,
+           int __base) -> from_chars_result {
+            using __tl = numeric_limits<_Tp>;
+            auto __digits = __tl::digits / log2f(float(__base));
+            _Tp __a = __in_pattern(*__p++, __base).__val, __b = 0;
+
+            for (int __i = 1; __p != __last; ++__i, ++__p)
+            {
+                if (auto __c = __in_pattern(*__p, __base))
+                {
+                    if (__i < __digits - 1)
+                        __a = __a * __base + __c.__val;
+                    else
+                    {
+                        if (!__itoa::__mul_overflowed(__a, __base, __a))
+                            ++__p;
+                        __b = __c.__val;
+                        break;
+                    }
+                }
+                else
+                    break;
+            }
+
+            if (__p == __last || !__in_pattern(*__p, __base))
+            {
+                if ((__tl::max)() - __a >= __b)
+                {
+                    __value = __a + __b;
+                    return {__p, {}};
+                }
+            }
+            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 auto
+__from_chars_integral(const char* __first, const char* __last, _Tp& __value,
+                      int __base) -> from_chars_result
+{
+    using __t = decltype(__to_unsigned(__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 auto
+from_chars(const char* __first, const char* __last, _Tp& __value)
+    -> from_chars_result
+{
+    return __from_chars_atoi(__first, __last, __value);
+}
+
+template <typename _Tp,
+          typename enable_if<is_integral<_Tp>::value, int>::type = 0>
+inline _LIBCPP_INLINE_VISIBILITY auto
+from_chars(const char* __first, const char* __last, _Tp& __value, int __base)
+    -> from_chars_result
+{
+    _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
+    return __from_chars_integral(__first, __last, __value, __base);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif  // _LIBCPP_CHARCONV

include/support/itoa/itoa.h

+// -*- C++ -*-
+//===--------------------- support/itoa/itoa.h ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SUPPORT_ITOA_ITOA_H
+#define _LIBCPP_SUPPORT_ITOA_ITOA_H
+
+#include <__config>
+#include <type_traits>
+#include <limits>
+#include <stdint.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __itoa
+{
+
+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 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),
+};
+
+#if __has_builtin(__builtin_clzll)
+
+inline _LIBCPP_INLINE_VISIBILITY auto
+__u64digits10(uint64_t __x) -> int
+{
+    auto __t = (64 - __builtin_clzll(__x | 1)) * 1233 >> 12;
+    return __t - (__x < __pow10_64[__t]) + 1;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY auto
+__u32digits10(uint32_t __x) -> int
+{
+    auto __t = (32 - __builtin_clz(__x | 1)) * 1233 >> 12;
+    return __t - (__x < __pow10_32[__t]) + 1;
+}
+
+#endif
+
+extern _LIBCPP_FUNC_VIS char* __u64toa(uint64_t __value, char* __buffer);
+extern _LIBCPP_FUNC_VIS char* __u32toa(uint32_t __value, char* __buffer);
+
+template <typename _Tp, typename = void>
+struct _LIBCPP_HIDDEN __traits
+{
+    static constexpr int digits = numeric_limits<_Tp>::digits10 + 1;
+    using type = uint64_t;
+
+#if __has_builtin(__builtin_clzll)
+    static _LIBCPP_INLINE_VISIBILITY auto width(_Tp __v) -> int
+    {
+        return __u64digits10(__v);
+    }
+#endif
+
+    static _LIBCPP_INLINE_VISIBILITY auto convert(_Tp __v, char* __p) -> char*
+    {
+        return __u64toa(__v, __p);
+    }
+
+    static _LIBCPP_INLINE_VISIBILITY auto pow() -> type const (&)[20]
+    {
+        return __pow10_64;
+    }
+};
+
+template <typename _Tp>
+struct _LIBCPP_HIDDEN __traits<_Tp, decltype(void(uint32_t{declval<_Tp>()}))>
+{
+    static constexpr int digits = numeric_limits<_Tp>::digits10 + 1;
+    using type = uint32_t;
+
+#if __has_builtin(__builtin_clzll)
+    static _LIBCPP_INLINE_VISIBILITY auto width(_Tp __v) -> int
+    {
+        return __u32digits10(__v);
+    }
+#endif
+
+    static _LIBCPP_INLINE_VISIBILITY auto convert(_Tp __v, char* __p) -> char*
+    {
+        return __u32toa(__v, __p);
+    }
+
+    static _LIBCPP_INLINE_VISIBILITY auto pow() -> type const (&)[10]
+    {
+        return __pow10_32;
+    }
+};
+
+template <typename _Tp>
+inline _LIBCPP_INLINE_VISIBILITY 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
+__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
+__mul_overflowed(_Tp __a, _Tp __b, _Tp& __r)
+{
+    static_assert(is_unsigned<_Tp>::value, "");
+#if __has_builtin(__builtin_mul_overflow)
+    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
+__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<_Tp>
+{
+    using __traits<_Tp>::digits;
+    using __traits<_Tp>::pow;
+    using typename __traits<_Tp>::type;
+
+    // precondition: at least one non-zero character available
+    static _LIBCPP_INLINE_VISIBILITY auto
+    read(char const* __p, char const* __ep, type& __a, type& __b) -> char const*
+    {
+        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 auto
+    inner_product(_It1 __first1, _It1 __last1, _It2 __first2, _Up __init) -> _Up
+    {
+        for (; __first1 < __last1; ++__first1, ++__first2)
+            __init = __init + *__first1 * *__first2;
+        return __init;
+    }
+};
+
+}  // namespace __itoa
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif  // _LIBCPP_SUPPORT_ITOA_ITOA_H

lib/CMakeLists.txt

 set(LIBCXX_LIB_CMAKEFILES_DIR "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}"  PARENT_SCOPE)
 
 # Get sources
 # FIXME: Don't use glob here
-file(GLOB LIBCXX_SOURCES ../src/*.cpp)
+file(GLOB LIBCXX_SOURCES ../src/*.cpp ../src/support/itoa/*.cpp)
 if(WIN32)
   file(GLOB LIBCXX_WIN32_SOURCES ../src/support/win32/*.cpp)
   list(APPEND LIBCXX_SOURCES ${LIBCXX_WIN32_SOURCES})
 elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
   file(GLOB LIBCXX_SOLARIS_SOURCES ../src/support/solaris/*.cpp)
   list(APPEND LIBCXX_SOURCES ${LIBCXX_SOLARIS_SOURCES})
 endif()
 

src/support/itoa/itoa.cpp

+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#include <support/itoa/itoa.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __itoa
+{
+
+static const char cDigitsLut[200] = {
+    '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0',
+    '7', '0', '8', '0', '9', '1', '0', '1', '1', '1', '2', '1', '3', '1', '4',
+    '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', '2', '0', '2', '1', '2',
+    '2', '2', '3', '2', '4', '2', '5', '2', '6', '2', '7', '2', '8', '2', '9',
+    '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3',
+    '7', '3', '8', '3', '9', '4', '0', '4', '1', '4', '2', '4', '3', '4', '4',
+    '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', '5', '0', '5', '1', '5',
+    '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7', '5', '8', '5', '9',
+    '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6',
+    '7', '6', '8', '6', '9', '7', '0', '7', '1', '7', '2', '7', '3', '7', '4',
+    '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', '8', '0', '8', '1', '8',
+    '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
+    '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9',
+    '7', '9', '8', '9', '9'};
+
+char*
+__u32toa(uint32_t value, char* buffer)
+{
+
+    if (value < 10000)
+    {
+        const uint32_t d1 = (value / 100) << 1;
+        const uint32_t d2 = (value % 100) << 1;
+
+        if (value >= 1000)
+            *buffer++ = cDigitsLut[d1];
+        if (value >= 100)
+            *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= 10)
+            *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+    }
+    else if (value < 100000000)
+    {
+        // value = bbbbcccc
+        const uint32_t b = value / 10000;
+        const uint32_t c = value % 10000;
+
+        const uint32_t d1 = (b / 100) << 1;
+        const uint32_t d2 = (b % 100) << 1;
+
+        const uint32_t d3 = (c / 100) << 1;
+        const uint32_t d4 = (c % 100) << 1;
+
+        if (value >= 10000000)
+            *buffer++ = cDigitsLut[d1];
+        if (value >= 1000000)
+            *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= 100000)
+            *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+    }
+    else
+    {
+        // value = aabbbbcccc in decimal
+
+        const uint32_t a = value / 100000000;  // 1 to 42
+        value %= 100000000;
+
+        if (a >= 10)
+        {
+            const unsigned i = a << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+        }
+        else
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
+
+        const uint32_t b = value / 10000;  // 0 to 9999
+        const uint32_t c = value % 10000;  // 0 to 9999
+
+        const uint32_t d1 = (b / 100) << 1;
+        const uint32_t d2 = (b % 100) << 1;
+
+        const uint32_t d3 = (c / 100) << 1;
+        const uint32_t d4 = (c % 100) << 1;
+
+        *buffer++ = cDigitsLut[d1];
+        *buffer++ = cDigitsLut[d1 + 1];
+        *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+    }
+    return buffer;
+}
+
+char*
+__u64toa(uint64_t value, char* buffer)
+{
+    const uint64_t kTen8 = 100000000;
+    const uint64_t kTen9 = kTen8 * 10;
+    const uint64_t kTen10 = kTen8 * 100;
+    const uint64_t kTen11 = kTen8 * 1000;
+    const uint64_t kTen12 = kTen8 * 10000;
+    const uint64_t kTen13 = kTen8 * 100000;
+    const uint64_t kTen14 = kTen8 * 1000000;
+    const uint64_t kTen15 = kTen8 * 10000000;
+    const uint64_t kTen16 = kTen8 * kTen8;
+
+    if (value < kTen8)
+    {
+        uint32_t v = static_cast<uint32_t>(value);
+        if (v < 10000)
+        {
+            const uint32_t d1 = (v / 100) << 1;
+            const uint32_t d2 = (v % 100) << 1;
+
+            if (v >= 1000)
+                *buffer++ = cDigitsLut[d1];
+            if (v >= 100)
+                *buffer++ = cDigitsLut[d1 + 1];
+            if (v >= 10)
+                *buffer++ = cDigitsLut[d2];
+            *buffer++ = cDigitsLut[d2 + 1];
+        }
+        else
+        {
+            // value = bbbbcccc
+            const uint32_t b = v / 10000;
+            const uint32_t c = v % 10000;
+
+            const uint32_t d1 = (b / 100) << 1;
+            const uint32_t d2 = (b % 100) << 1;
+
+            const uint32_t d3 = (c / 100) << 1;
+            const uint32_t d4 = (c % 100) << 1;
+
+            if (value >= 10000000)
+                *buffer++ = cDigitsLut[d1];
+            if (value >= 1000000)
+                *buffer++ = cDigitsLut[d1 + 1];
+            if (value >= 100000)
+                *buffer++ = cDigitsLut[d2];
+            *buffer++ = cDigitsLut[d2 + 1];
+
+            *buffer++ = cDigitsLut[d3];
+            *buffer++ = cDigitsLut[d3 + 1];
+            *buffer++ = cDigitsLut[d4];
+            *buffer++ = cDigitsLut[d4 + 1];
+        }
+    }
+    else if (value < kTen16)
+    {
+        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
+        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
+
+        const uint32_t b0 = v0 / 10000;
+        const uint32_t c0 = v0 % 10000;
+
+        const uint32_t d1 = (b0 / 100) << 1;
+        const uint32_t d2 = (b0 % 100) << 1;
+
+        const uint32_t d3 = (c0 / 100) << 1;
+        const uint32_t d4 = (c0 % 100) << 1;
+
+        const uint32_t b1 = v1 / 10000;
+        const uint32_t c1 = v1 % 10000;
+
+        const uint32_t d5 = (b1 / 100) << 1;
+        const uint32_t d6 = (b1 % 100) << 1;
+
+        const uint32_t d7 = (c1 / 100) << 1;
+        const uint32_t d8 = (c1 % 100) << 1;
+
+        if (value >= kTen15)
+            *buffer++ = cDigitsLut[d1];
+        if (value >= kTen14)
+            *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= kTen13)
+            *buffer++ = cDigitsLut[d2];
+        if (value >= kTen12)
+            *buffer++ = cDigitsLut[d2 + 1];
+        if (value >= kTen11)
+            *buffer++ = cDigitsLut[d3];
+        if (value >= kTen10)
+            *buffer++ = cDigitsLut[d3 + 1];
+        if (value >= kTen9)
+            *buffer++ = cDigitsLut[d4];
+        if (value >= kTen8)
+            *buffer++ = cDigitsLut[d4 + 1];
+
+        *buffer++ = cDigitsLut[d5];
+        *buffer++ = cDigitsLut[d5 + 1];
+        *buffer++ = cDigitsLut[d6];
+        *buffer++ = cDigitsLut[d6 + 1];
+        *buffer++ = cDigitsLut[d7];
+        *buffer++ = cDigitsLut[d7 + 1];
+        *buffer++ = cDigitsLut[d8];
+        *buffer++ = cDigitsLut[d8 + 1];
+    }
+    else
+    {
+        const uint32_t a = static_cast<uint32_t>(value / kTen16);  // 1 to 1844
+        value %= kTen16;
+
+        if (a < 10)
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
+        else if (a < 100)
+        {
+            const uint32_t i = a << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+        }
+        else if (a < 1000)
+        {
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
+
+            const uint32_t i = (a % 100) << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+        }
+        else
+        {
+            const uint32_t i = (a / 100) << 1;
+            const uint32_t j = (a % 100) << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+            *buffer++ = cDigitsLut[j];
+            *buffer++ = cDigitsLut[j + 1];
+        }
+
+        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
+        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
+
+        const uint32_t b0 = v0 / 10000;
+        const uint32_t c0 = v0 % 10000;
+
+        const uint32_t d1 = (b0 / 100) << 1;
+        const uint32_t d2 = (b0 % 100) << 1;
+
+        const uint32_t d3 = (c0 / 100) << 1;
+        const uint32_t d4 = (c0 % 100) << 1;
+
+        const uint32_t b1 = v1 / 10000;
+        const uint32_t c1 = v1 % 10000;
+
+        const uint32_t d5 = (b1 / 100) << 1;
+        const uint32_t d6 = (b1 % 100) << 1;
+
+        const uint32_t d7 = (c1 / 100) << 1;
+        const uint32_t d8 = (c1 % 100) << 1;
+
+        *buffer++ = cDigitsLut[d1];
+        *buffer++ = cDigitsLut[d1 + 1];
+        *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+        *buffer++ = cDigitsLut[d5];
+        *buffer++ = cDigitsLut[d5 + 1];
+        *buffer++ = cDigitsLut[d6];
+        *buffer++ = cDigitsLut[d6 + 1];
+        *buffer++ = cDigitsLut[d7];
+        *buffer++ = cDigitsLut[d7 + 1];
+        *buffer++ = cDigitsLut[d8];
+        *buffer++ = cDigitsLut[d8 + 1];
+    }
+
+    return buffer;
+}
+
+}  // namespace __itoa
+
+_LIBCPP_END_NAMESPACE_STD

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+// <charconv>
+
+// In
+//
+// from_chars_result from_chars(const char* first, const char* last,
+//                              Integral& value, int base = 10)
+//
+// Integral cannot be bool.
+
+#include <charconv>
+
+int main()
+{
+    using std::from_chars;
+    char buf[] = "01001";
+    bool lv;
+
+    from_chars(buf, buf + sizeof(buf), lv);      // expected-error {{call to deleted function}}
+    from_chars(buf, buf + sizeof(buf), lv, 16);  // expected-error {{call to deleted function}}
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+// <charconv>
+
+// from_chars_result from_chars(const char* first, const char* last,
+//                              Integral& value, int base = 10)
+
+#include "charconv_test_helpers.h"
+
+template <typename T>
+struct test_basics : roundtrip_test_base<T>
+{
+    using roundtrip_test_base<T>::test;
+
+    void operator()()
+    {
+        test(0);
+        test(42);
+        test(32768);
+        test(0, 10);
+        test(42, 10);
+        test(32768, 10);
+        test(0xf, 16);
+        test(0xdeadbeaf, 16);
+        test(0755, 8);
+
+        for (int b = 2; b < 37; ++b)
+        {
+            using xl = std::numeric_limits<T>;
+
+            test(1, b);
+            test(xl::lowest(), b);
+            test((xl::max)(), b);
+            test((xl::max)() / 2, b);
+        }
+
+        using std::from_chars;
+        std::from_chars_result r;
+        T x;
+
+        {
+            char s[] = "001x";
+
+            // the expected form of the subject sequence is a sequence of
+            // letters and digits representing an integer with the radix
+            // specified by base (C11 7.22.1.4/3)
+            r = from_chars(s, s + sizeof(s), x);
+            LIBCPP_ASSERT(r.ec == std::errc{});
+            LIBCPP_ASSERT(r.ptr == s + 3);
+            LIBCPP_ASSERT(x == 1);
+        }
+
+        {
+            char s[] = "0X7BAtSGHDkEIXZg ";
+
+            // The letters from a (or A) through z (or Z) are ascribed the
+            // values 10 through 35; (C11 7.22.1.4/3)
+            r = from_chars(s, s + sizeof(s), x, 36);
+            LIBCPP_ASSERT(r.ec == std::errc::result_out_of_range);
+            // The member ptr of the return value points to the first character
+            // not matching the pattern
+            LIBCPP_ASSERT(r.ptr == s + sizeof(s) - 2);
+            LIBCPP_ASSERT(x == 1);
+
+            // no "0x" or "0X" prefix shall appear if the value of base is 16
+            r = from_chars(s, s + sizeof(s), x, 16);
+            LIBCPP_ASSERT(r.ec == std::errc{});
+            LIBCPP_ASSERT(r.ptr == s + 1);
+            LIBCPP_ASSERT(x == 0);
+
+            // only letters and digits whose ascribed values are less than that
+            // of base are permitted. (C11 7.22.1.4/3)
+            r = from_chars(s + 2, s + sizeof(s), x, 12);
+            // If the parsed value is not in the range representable by the type
+            // of value,
+            if (!fits_in<T>(1150))
+            {
+                // value is unmodified and
+                LIBCPP_ASSERT(x == 0);
+                // the member ec of the return value is equal to
+                // errc::result_out_of_range
+                LIBCPP_ASSERT(r.ec == std::errc::result_out_of_range);
+            }
+            else
+            {
+                // Otherwise, value is set to the parsed value,
+                LIBCPP_ASSERT(x == 1150);
+                // and the member ec is value-initialized.
+                LIBCPP_ASSERT(r.ec == std::errc{});
+            }
+            LIBCPP_ASSERT(r.ptr == s + 5);
+        }
+    }
+};
+
+template <typename T>
+struct test_signed : roundtrip_test_base<T>
+{
+    using roundtrip_test_base<T>::test;
+
+    void operator()()
+    {
+        test(-1);
+        test(-12);
+        test(-1, 10);
+        test(-12, 10);
+        test(-21734634, 10);
+        test(-2647, 2);
+        test(-0xcc1, 16);
+
+        for (int b = 2; b < 37; ++b)
+        {
+            using xl = std::numeric_limits<T>;
+
+            test(0, b);
+            test(xl::lowest(), b);
+            test((xl::max)(), b);
+        }
+
+        using std::from_chars;
+        std::from_chars_result r;
+        T x;
+
+        {
+            // If the pattern allows for an optional sign,
+            char s[] = " - 9+12";
+            // but the string has no digit characters following the sign,
+            r = from_chars(s + 1, s + sizeof(s), x);
+            // no characters match the pattern.
+            LIBCPP_ASSERT(r.ptr == s + 1);
+            LIBCPP_ASSERT(r.ec == std::errc::invalid_argument);
+
+            // a minus sign is the only sign that may appear
+            r = from_chars(s + 3, s + sizeof(s), x);
+            LIBCPP_ASSERT(r.ec == std::errc{});
+            // The member ptr of the return value points to the first character
+            // not matching the pattern,
+            LIBCPP_ASSERT(r.ptr == s + 4);
+            LIBCPP_ASSERT(x == 9);
+
+            r = from_chars(s + 5, s + 7, x);
+            LIBCPP_ASSERT(r.ec == std::errc{});
+            // or has the value last if all characters match.
+            LIBCPP_ASSERT(r.ptr == s + 7);
+            LIBCPP_ASSERT(x == 12);
+
+            // If no characters match the pattern,
+            r = from_chars(s + 4, s + sizeof(s), x);
+            // value is unmodified,
+            LIBCPP_ASSERT(x == 12);
+            // the member ptr of the return value is first and
+            LIBCPP_ASSERT(r.ptr == s + 4);
+            // the member ec is equal to errc::invalid_argument.
+            LIBCPP_ASSERT(r.ec == std::errc::invalid_argument);
+        }
+    }
+};
+
+int
+main()
+{
+    run<test_basics>(integrals);
+    run<test_signed>(all_signed);
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+// <charconv>
+
+// In
+//
+// to_chars_result to_chars(char* first, char* last, Integral value,
+//                          int base = 10)
+//
+// Integral cannot be bool.
+
+#include <charconv>
+
+int main()
+{
+    using std::to_chars;
+    char buf[10];
+    bool lv = true;
+
+    to_chars(buf, buf + sizeof(buf), false);   // expected-error {{call to deleted function}}
+    to_chars(buf, buf + sizeof(buf), lv, 16);  // expected-error {{call to deleted function}}
+}

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

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+// <charconv>
+
+// to_chars_result to_chars(char* first, char* last, Integral value,
+//                          int base = 10)
+
+#include "charconv_test_helpers.h"
+
+template <typename T>
+struct test_basics : to_chars_test_base<T>
+{
+    using to_chars_test_base<T>::test;
+    using to_chars_test_base<T>::test_value;
+
+    void operator()()
+    {
+        test(0, "0");
+        test(42, "42");
+        test(32768, "32768");
+        test(0, "0", 10);
+        test(42, "42", 10);
+        test(32768, "32768", 10);
+        test(0xf, "f", 16);
+        test(0xdeadbeaf, "deadbeaf", 16);
+        test(0755, "755", 8);
+
+        for (int b = 2; b < 37; ++b)
+        {
+            using xl = std::numeric_limits<T>;
+
+            test_value(1, b);
+            test_value(xl::lowest(), b);
+            test_value((xl::max)(), b);
+            test_value((xl::max)() / 2, b);
+        }
+    }
+};
+
+template <typename T>
+struct test_signed : to_chars_test_base<T>
+{
+    using to_chars_test_base<T>::test;
+    using to_chars_test_base<T>::test_value;
+
+    void operator()()
+    {
+        test(-1, "-1");
+        test(-12, "-12");
+        test(-1, "-1", 10);
+        test(-12, "-12", 10);
+        test(-21734634, "-21734634", 10);
+        test(-2647, "-101001010111", 2);
+        test(-0xcc1, "-cc1", 16);
+
+        for (int b = 2; b < 37; ++b)
+        {
+            using xl = std::numeric_limits<T>;
+
+            test_value(0, b);
+            test_value(xl::lowest(), b);
+            test_value((xl::max)(), b);
+        }
+    }
+};
+
+int
+main()
+{
+    run<test_basics>(integrals);
+    run<test_signed>(all_signed);
+}

test/support/charconv_test_helpers.h

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_CHARCONV_TEST_HELPERS_H
+#define SUPPORT_CHARCONV_TEST_HELPERS_H
+
+#include <charconv>
+#include <cassert>
+#include <limits>
+#include <string.h>
+#include <stdlib.h>
+
+#include "test_macros.h"
+
+using std::false_type;
+using std::true_type;
+
+template <typename To, typename From>
+constexpr auto
+is_non_narrowing(From a) -> decltype(To{a}, true_type())
+{
+    return {};
+}
+
+template <typename To>
+constexpr auto
+is_non_narrowing(...) -> false_type
+{
+    return {};
+}
+
+template <typename X, typename T>
+constexpr bool
+_fits_in(T, true_type /* non-narrowing*/, ...)
+{
+    return true;
+}
+
+template <typename X, typename T, typename xl = std::numeric_limits<X>>
+constexpr bool
+_fits_in(T v, false_type, true_type /* T signed*/, true_type /* X signed */)
+{
+    return xl::lowest() <= v && v <= (xl::max)();
+}
+
+template <typename X, typename T, typename xl = std::numeric_limits<X>>
+constexpr bool
+_fits_in(T v, false_type, true_type /* T signed */, false_type /* X unsigned*/)
+{
+    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 <= typename std::make_unsigned<X>::type((xl::max)());
+}
+
+template <typename X, typename T>
+constexpr bool
+fits_in(T v)
+{
+    return _fits_in<X>(v, is_non_narrowing<X>(v), std::is_signed<T>(),
+                       std::is_signed<X>());
+}
+
+template <typename X>
+struct to_chars_test_base
+{
+    template <typename T, size_t N, typename... Ts>
+    void test(T v, char const (&expect)[N], Ts... args)
+    {
+        using std::to_chars;
+        std::to_chars_result r;
+
+        constexpr size_t len = N - 1;
+        static_assert(len > 0, "expected output won't be empty");
+
+        if (!fits_in<X>(v))
+            return;
+
+        r = to_chars(buf, buf + len - 1, X(v), args...);
+        LIBCPP_ASSERT(r.ptr == buf + len - 1);
+        LIBCPP_ASSERT(r.ec == std::errc::value_too_large);
+
+        r = to_chars(buf, buf + sizeof(buf), X(v), args...);
+        LIBCPP_ASSERT(r.ptr == buf + len);
+        LIBCPP_ASSERT(r.ec == std::errc{});
+        LIBCPP_ASSERT(memcmp(buf, expect, len) == 0);
+    }
+
+    template <typename... Ts>
+    void test_value(X v, Ts... args)
+    {
+        using std::to_chars;
+        std::to_chars_result r;
+
+        r = to_chars(buf, buf + sizeof(buf), v, args...);
+        LIBCPP_ASSERT(r.ec == std::errc{});
+        *r.ptr = '\0';
+
+        auto a = fromchars(buf, r.ptr, args...);
+        LIBCPP_ASSERT(v == a);
+
+        auto ep = r.ptr - 1;
+        r = to_chars(buf, ep, v, args...);
+        LIBCPP_ASSERT(r.ptr == ep);
+        LIBCPP_ASSERT(r.ec == std::errc::value_too_large);
+    }
+
+private:
+    using max_t = typename std::conditional<std::is_signed<X>::value, long long,
+                                            unsigned long long>::type;
+
+    static auto fromchars(char const* p, char const* ep, int base, true_type)
+        -> long long
+    {
+        char* last;
+        auto r = strtoll(p, &last, base);
+        LIBCPP_ASSERT(last == ep);
+
+        return r;
+    }
+
+    static auto fromchars(char const* p, char const* ep, int base, false_type)
+        -> unsigned long long
+    {
+        char* last;
+        auto r = strtoull(p, &last, base);
+        LIBCPP_ASSERT(last == ep);
+
+        return r;
+    }
+
+    static auto fromchars(char const* p, char const* ep, int base = 10) -> max_t
+    {
+        return fromchars(p, ep, base, std::is_signed<X>());
+    }
+
+    char buf[100];
+};
+
+template <typename X>
+struct roundtrip_test_base
+{
+    template <typename T, typename... Ts>
+    void test(T v, Ts... args)
+    {
+        using std::from_chars;
+        using std::to_chars;
+        std::from_chars_result r2;
+        std::to_chars_result r;
+        X x = 0xc;
+
+        if (fits_in<X>(v))
+        {
+            r = to_chars(buf, buf + sizeof(buf), v, args...);
+            LIBCPP_ASSERT(r.ec == std::errc{});
+
+            r2 = from_chars(buf, r.ptr, x, args...);
+            LIBCPP_ASSERT(r2.ptr == r.ptr);
+            LIBCPP_ASSERT(x == X(v));
+        }
+        else
+        {
+            r = to_chars(buf, buf + sizeof(buf), v, args...);
+            LIBCPP_ASSERT(r.ec == std::errc{});
+
+            r2 = from_chars(buf, r.ptr, x, args...);
+
+            if (std::is_signed<T>::value && v < 0 && std::is_unsigned<X>::value)
+            {
+                LIBCPP_ASSERT(x == 0xc);
+                LIBCPP_ASSERT(r2.ptr == buf);
+                LIBCPP_ASSERT(r.ec == std::errc::invalid_argument);
+            }
+            else
+            {
+                LIBCPP_ASSERT(x == 0xc);
+                LIBCPP_ASSERT(r2.ptr == r.ptr);
+                LIBCPP_ASSERT(r2.ec == std::errc::result_out_of_range);
+            }
+        }
+    }
+
+private:
+    char buf[100];
+};
+
+template <typename... T>
+struct type_list
+{
+};
+
+template <typename L1, typename L2>
+struct type_concat;
+
+template <typename... Xs, typename... Ys>
+struct type_concat<type_list<Xs...>, type_list<Ys...>>
+{
+    using type = type_list<Xs..., Ys...>;
+};
+
+template <typename L1, typename L2>
+using concat_t = typename type_concat<L1, L2>::type;
+
+template <typename L1, typename L2>
+constexpr auto concat(L1, L2) -> concat_t<L1, L2>
+{
+    return {};
+}
+
+auto all_signed = type_list<char, signed char, short, int, long, long long>();
+auto all_unsigned = type_list<unsigned char, unsigned short, unsigned int,
+                              unsigned long, unsigned long long>();
+auto integrals = concat(all_signed, all_unsigned);
+
+template <template <typename> class Fn, typename... Ts>
+void
+run(type_list<Ts...>)
+{
+    int ls[sizeof...(Ts)] = {(Fn<Ts>{}(), 0)...};
+    (void)ls;
+}
+
+#endif  // SUPPORT_CHARCONV_TEST_HELPERS_H