This is an archive of the discontinued LLVM Phabricator instance.

Differential D126887

[libc++] Don't use static constexpr in headers.
ClosedPublic

Authored by Mordante on Jun 2 2022, 8:27 AM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rGdea7a8e616da: [libc++] Don't use static constexpr in headers.
Summary

This was noticed in the review of D125704. In that commit only the new
table has been adapted. This adapts the existing tables.

Note since libc++'s charconv is backported to C++11 it's not possible to
use inline constexpr variables. The were introduced in C++17.

Diff Detail

Unit TestsFailed

TimeTest
1,200,170 mslibcxx CI AIX (32-bit) > ibm-libc++-shared-cfg-in.std/algorithms/alg_modifying_operations/alg_transform::ranges.transform.pass.cpp

Event Timeline

Mordante created this revision.Jun 2 2022, 8:27 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 2 2022, 8:27 AM
Mordante requested review of this revision.Jun 2 2022, 8:27 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 2 2022, 8:27 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B167526: Diff 433762.Jun 2 2022, 1:40 PM
ldionne accepted this revision.Jun 7 2022, 8:43 AM
This revision is now accepted and ready to land.Jun 7 2022, 8:43 AM
This revision was landed with ongoing or failed builds.Jun 7 2022, 9:47 AM
Closed by commit rGdea7a8e616da: [libc++] Don't use static constexpr in headers. (authored by Mordante). · Explain Why
This revision was automatically updated to reflect the committed changes.
Mordante added a commit: rGdea7a8e616da: [libc++] Don't use static constexpr in headers..

Revision Contents

PathSize
libcxx/
include/
__charconv/
85 lines
2 lines
92 lines
src/
include/
ryu/
2 lines

Diff 433762

libcxx/include/__charconv/tables.h

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___CHARCONV_TABLES #ifndef _LIBCPP___CHARCONV_TABLES
#define _LIBCPP___CHARCONV_TABLES #define _LIBCPP___CHARCONV_TABLES
#include <__config> #include <__config>
#include <cstdint>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
namespace __itoa { namespace __itoa {
/// Contains the charconv helper tables.
///
/// In C++17 these could be inline constexpr variable, but libc++ supports
/// charconv for integrals in C++11 mode.
template <class = void> template <class = void>
struct __digits_base_10 { struct __table {
static const char __value[200]; static const char __base_2_lut[64];
static const char __base_8_lut[128];
static const char __base_16_lut[512];
static const uint32_t __pow10_32[10];
static const uint64_t __pow10_64[20];
static const char __digits_base_10[200];
}; };
template <class _Tp> template <class _Tp>
const char __digits_base_10<_Tp>::__value[200] = { const char __table<_Tp>::__base_2_lut[64] = {
'0', '0', '0', '0', '0', '0', '0', '1', '0', '0', '1', '0', '0', '0', '1', '1', '0', '1', '0', '0', '0', '1',
'0', '1', '0', '1', '1', '0', '0', '1', '1', '1', '1', '0', '0', '0', '1', '0', '0', '1', '1', '0', '1', '0',
'1', '0', '1', '1', '1', '1', '0', '0', '1', '1', '0', '1', '1', '1', '1', '0', '1', '1', '1', '1'};
template <class _Tp>
const char __table<_Tp>::__base_8_lut[128] = {
'0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '1', '0', '1', '1', '1', '2',
'1', '3', '1', '4', '1', '5', '1', '6', '1', '7', '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', '2', '5',
'2', '6', '2', '7', '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3', '7', '4', '0',
'4', '1', '4', '2', '4', '3', '4', '4', '4', '5', '4', '6', '4', '7', '5', '0', '5', '1', '5', '2', '5', '3',
'5', '4', '5', '5', '5', '6', '5', '7', '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6',
'6', '7', '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7'};
template <class _Tp>
const char __table<_Tp>::__base_16_lut[512] = {
'0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', '0', 'a', '0',
'b', '0', 'c', '0', 'd', '0', 'e', '0', 'f', '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6',
'1', '7', '1', '8', '1', '9', '1', 'a', '1', 'b', '1', 'c', '1', 'd', '1', 'e', '1', 'f', '2', '0', '2', '1', '2',
'2', '2', '3', '2', '4', '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', '2', 'a', '2', 'b', '2', 'c', '2', 'd',
'2', 'e', '2', 'f', '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3', '7', '3', '8', '3',
'9', '3', 'a', '3', 'b', '3', 'c', '3', 'd', '3', 'e', '3', 'f', '4', '0', '4', '1', '4', '2', '4', '3', '4', '4',
'4', '5', '4', '6', '4', '7', '4', '8', '4', '9', '4', 'a', '4', 'b', '4', 'c', '4', 'd', '4', 'e', '4', 'f', '5',
'0', '5', '1', '5', '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', '5', 'a', '5', 'b',
'5', 'c', '5', 'd', '5', 'e', '5', 'f', '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6',
'7', '6', '8', '6', '9', '6', 'a', '6', 'b', '6', 'c', '6', 'd', '6', 'e', '6', 'f', '7', '0', '7', '1', '7', '2',
'7', '3', '7', '4', '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', '7', 'a', '7', 'b', '7', 'c', '7', 'd', '7',
'e', '7', 'f', '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
'8', 'a', '8', 'b', '8', 'c', '8', 'd', '8', 'e', '8', 'f', '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9',
'5', '9', '6', '9', '7', '9', '8', '9', '9', '9', 'a', '9', 'b', '9', 'c', '9', 'd', '9', 'e', '9', 'f', 'a', '0',
'a', '1', 'a', '2', 'a', '3', 'a', '4', 'a', '5', 'a', '6', 'a', '7', 'a', '8', 'a', '9', 'a', 'a', 'a', 'b', 'a',
'c', 'a', 'd', 'a', 'e', 'a', 'f', 'b', '0', 'b', '1', 'b', '2', 'b', '3', 'b', '4', 'b', '5', 'b', '6', 'b', '7',
'b', '8', 'b', '9', 'b', 'a', 'b', 'b', 'b', 'c', 'b', 'd', 'b', 'e', 'b', 'f', 'c', '0', 'c', '1', 'c', '2', 'c',
'3', 'c', '4', 'c', '5', 'c', '6', 'c', '7', 'c', '8', 'c', '9', 'c', 'a', 'c', 'b', 'c', 'c', 'c', 'd', 'c', 'e',
'c', 'f', 'd', '0', 'd', '1', 'd', '2', 'd', '3', 'd', '4', 'd', '5', 'd', '6', 'd', '7', 'd', '8', 'd', '9', 'd',
'a', 'd', 'b', 'd', 'c', 'd', 'd', 'd', 'e', 'd', 'f', 'e', '0', 'e', '1', 'e', '2', 'e', '3', 'e', '4', 'e', '5',
'e', '6', 'e', '7', 'e', '8', 'e', '9', 'e', 'a', 'e', 'b', 'e', 'c', 'e', 'd', 'e', 'e', 'e', 'f', 'f', '0', 'f',
'1', 'f', '2', 'f', '3', 'f', '4', 'f', '5', 'f', '6', 'f', '7', 'f', '8', 'f', '9', 'f', 'a', 'f', 'b', 'f', 'c',
'f', 'd', 'f', 'e', 'f', 'f'};
template <class _Tp>
const uint32_t __table<_Tp>::__pow10_32[10] = {
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 <class _Tp>
const uint64_t __table<_Tp>::__pow10_64[20] = {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)};
template <class _Tp>
const char __table<_Tp>::__digits_base_10[200] = {
// clang-format off // clang-format off
'0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', '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', '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', '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', '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', '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', '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', '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7', '6', '8', '6', '9',
Show All 12 Lines

libcxx/include/__charconv/to_chars_base_10.h

Show All 27 Lines
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI char* __append1(char* __buffer, _Tp __value) noexcept { _LIBCPP_HIDE_FROM_ABI char* __append1(char* __buffer, _Tp __value) noexcept {
*__buffer = '0' + static_cast<char>(__value); *__buffer = '0' + static_cast<char>(__value);
return __buffer + 1; return __buffer + 1;
} }
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI char* __append2(char* __buffer, _Tp __value) noexcept { _LIBCPP_HIDE_FROM_ABI char* __append2(char* __buffer, _Tp __value) noexcept {
std::memcpy(__buffer, &__digits_base_10<>::__value[(__value)*2], 2); std::memcpy(__buffer, &__table<>::__digits_base_10[(__value)*2], 2);
return __buffer + 2; return __buffer + 2;
} }
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI char* __append3(char* __buffer, _Tp __value) noexcept { _LIBCPP_HIDE_FROM_ABI char* __append3(char* __buffer, _Tp __value) noexcept {
return __itoa::__append2(__itoa::__append1(__buffer, (__value) / 100), (__value) % 100); return __itoa::__append2(__itoa::__append1(__buffer, (__value) / 100), (__value) % 100);
} }
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/include/charconv

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
to_chars_result to_chars(char*, char*, bool, int = 10) = delete; to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
from_chars_result from_chars(const char*, const char*, bool, int = 10) = delete; from_chars_result from_chars(const char*, const char*, bool, int = 10) = delete;
namespace __itoa namespace __itoa
{ {
static 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),
};
template <typename _Tp, typename = void> template <typename _Tp, typename = void>
struct _LIBCPP_HIDDEN __traits_base struct _LIBCPP_HIDDEN __traits_base
{ {
using type = uint64_t; using type = uint64_t;
static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v)
{ {
auto __t = (64 - std::__libcpp_clz(static_cast<type>(__v | 1))) * 1233 >> 12; auto __t = (64 - std::__libcpp_clz(static_cast<type>(__v | 1))) * 1233 >> 12;
return __t - (__v < __pow10_64[__t]) + 1; return __t - (__v < __table<>::__pow10_64[__t]) + 1;
} }
_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_AVAILABILITY_TO_CHARS
static _LIBCPP_HIDE_FROM_ABI char* __convert(_Tp __v, char* __p) static _LIBCPP_HIDE_FROM_ABI char* __convert(_Tp __v, char* __p)
{ {
return __itoa::__base_10_u64(__v, __p); return __itoa::__base_10_u64(__v, __p);
} }
static _LIBCPP_HIDE_FROM_ABI decltype(__pow10_64)& __pow() { return __pow10_64; } static _LIBCPP_HIDE_FROM_ABI decltype(__table<>::__pow10_64)& __pow() { return __table<>::__pow10_64; }
}; };
template <typename _Tp> template <typename _Tp>
struct _LIBCPP_HIDDEN struct _LIBCPP_HIDDEN
__traits_base<_Tp, decltype(void(uint32_t{declval<_Tp>()}))> __traits_base<_Tp, decltype(void(uint32_t{declval<_Tp>()}))>
{ {
using type = uint32_t; using type = uint32_t;
static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) static _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v)
{ {
auto __t = (32 - std::__libcpp_clz(static_cast<type>(__v | 1))) * 1233 >> 12; auto __t = (32 - std::__libcpp_clz(static_cast<type>(__v | 1))) * 1233 >> 12;
return __t - (__v < __pow10_32[__t]) + 1; return __t - (__v < __table<>::__pow10_32[__t]) + 1;
} }
_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_AVAILABILITY_TO_CHARS
static _LIBCPP_HIDE_FROM_ABI char* __convert(_Tp __v, char* __p) static _LIBCPP_HIDE_FROM_ABI char* __convert(_Tp __v, char* __p)
{ {
return __itoa::__base_10_u32(__v, __p); return __itoa::__base_10_u32(__v, __p);
} }
static _LIBCPP_HIDE_FROM_ABI decltype(__pow10_32)& __pow() { return __pow10_32; } static _LIBCPP_HIDE_FROM_ABI decltype(__table<>::__pow10_32)& __pow() { return __table<>::__pow10_32; }
}; };
template <typename _Tp> template <typename _Tp>
inline _LIBCPP_HIDE_FROM_ABI bool inline _LIBCPP_HIDE_FROM_ABI bool
__mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r) __mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r)
{ {
auto __c = __a * __b; auto __c = __a * __b;
__r = __c; __r = __c;
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines if (__value < 0 && __first != __last)
__x = __complement(__x); __x = __complement(__x);
} }
return __to_chars_integral(__first, __last, __x, __base, false_type()); return __to_chars_integral(__first, __last, __x, __base, false_type());
} }
namespace __itoa { namespace __itoa {
static constexpr char __base_2_lut[64] = {
'0', '0', '0', '0',
'0', '0', '0', '1',
'0', '0', '1', '0',
'0', '0', '1', '1',
'0', '1', '0', '0',
'0', '1', '0', '1',
'0', '1', '1', '0',
'0', '1', '1', '1',
'1', '0', '0', '0',
'1', '0', '0', '1',
'1', '0', '1', '0',
'1', '0', '1', '1',
'1', '1', '0', '0',
'1', '1', '0', '1',
'1', '1', '1', '0',
'1', '1', '1', '1'
};
static constexpr char __base_8_lut[128] = {
'0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7',
'1', '0', '1', '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6', '1', '7',
'2', '0', '2', '1', '2', '2', '2', '3', '2', '4', '2', '5', '2', '6', '2', '7',
'3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3', '7',
'4', '0', '4', '1', '4', '2', '4', '3', '4', '4', '4', '5', '4', '6', '4', '7',
'5', '0', '5', '1', '5', '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7',
'6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7',
'7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7'
};
static constexpr char __base_16_lut[512] = {
'0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', '0', 'a', '0', 'b', '0', 'c', '0', 'd', '0', 'e', '0', 'f',
'1', '0', '1', '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', '1', 'a', '1', 'b', '1', 'c', '1', 'd', '1', 'e', '1', 'f',
'2', '0', '2', '1', '2', '2', '2', '3', '2', '4', '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', '2', 'a', '2', 'b', '2', 'c', '2', 'd', '2', 'e', '2', 'f',
'3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', '3', 'a', '3', 'b', '3', 'c', '3', 'd', '3', 'e', '3', 'f',
'4', '0', '4', '1', '4', '2', '4', '3', '4', '4', '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', '4', 'a', '4', 'b', '4', 'c', '4', 'd', '4', 'e', '4', 'f',
'5', '0', '5', '1', '5', '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', '5', 'a', '5', 'b', '5', 'c', '5', 'd', '5', 'e', '5', 'f',
'6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7', '6', '8', '6', '9', '6', 'a', '6', 'b', '6', 'c', '6', 'd', '6', 'e', '6', 'f',
'7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', '7', 'a', '7', 'b', '7', 'c', '7', 'd', '7', 'e', '7', 'f',
'8', '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', '8', 'a', '8', 'b', '8', 'c', '8', 'd', '8', 'e', '8', 'f',
'9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9', '9', 'a', '9', 'b', '9', 'c', '9', 'd', '9', 'e', '9', 'f',
'a', '0', 'a', '1', 'a', '2', 'a', '3', 'a', '4', 'a', '5', 'a', '6', 'a', '7', 'a', '8', 'a', '9', 'a', 'a', 'a', 'b', 'a', 'c', 'a', 'd', 'a', 'e', 'a', 'f',
'b', '0', 'b', '1', 'b', '2', 'b', '3', 'b', '4', 'b', '5', 'b', '6', 'b', '7', 'b', '8', 'b', '9', 'b', 'a', 'b', 'b', 'b', 'c', 'b', 'd', 'b', 'e', 'b', 'f',
'c', '0', 'c', '1', 'c', '2', 'c', '3', 'c', '4', 'c', '5', 'c', '6', 'c', '7', 'c', '8', 'c', '9', 'c', 'a', 'c', 'b', 'c', 'c', 'c', 'd', 'c', 'e', 'c', 'f',
'd', '0', 'd', '1', 'd', '2', 'd', '3', 'd', '4', 'd', '5', 'd', '6', 'd', '7', 'd', '8', 'd', '9', 'd', 'a', 'd', 'b', 'd', 'c', 'd', 'd', 'd', 'e', 'd', 'f',
'e', '0', 'e', '1', 'e', '2', 'e', '3', 'e', '4', 'e', '5', 'e', '6', 'e', '7', 'e', '8', 'e', '9', 'e', 'a', 'e', 'b', 'e', 'c', 'e', 'd', 'e', 'e', 'e', 'f',
'f', '0', 'f', '1', 'f', '2', 'f', '3', 'f', '4', 'f', '5', 'f', '6', 'f', '7', 'f', '8', 'f', '9', 'f', 'a', 'f', 'b', 'f', 'c', 'f', 'd', 'f', 'e', 'f', 'f'
};
template <unsigned _Base> template <unsigned _Base>
struct _LIBCPP_HIDDEN __integral; struct _LIBCPP_HIDDEN __integral;
template <> template <>
struct _LIBCPP_HIDDEN __integral<2> { struct _LIBCPP_HIDDEN __integral<2> {
template <typename _Tp> template <typename _Tp>
_LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept { _LIBCPP_HIDE_FROM_ABI static constexpr int __width(_Tp __value) noexcept {
// If value == 0 still need one digit. If the value != this has no // If value == 0 still need one digit. If the value != this has no
Show All 11 Lines _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) {
__last = __first + __n; __last = __first + __n;
char* __p = __last; char* __p = __last;
const unsigned __divisor = 16; const unsigned __divisor = 16;
while (__value > __divisor) { while (__value > __divisor) {
unsigned __c = __value % __divisor; unsigned __c = __value % __divisor;
__value /= __divisor; __value /= __divisor;
__p -= 4; __p -= 4;
std::memcpy(__p, &__base_2_lut[4 * __c], 4); std::memcpy(__p, &__table<>::__base_2_lut[4 * __c], 4);
} }
do { do {
unsigned __c = __value % 2; unsigned __c = __value % 2;
__value /= 2; __value /= 2;
*--__p = "01"[__c]; *--__p = "01"[__c];
} while (__value != 0); } while (__value != 0);
return {__last, errc(0)}; return {__last, errc(0)};
} }
Show All 18 Lines _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) {
__last = __first + __n; __last = __first + __n;
char* __p = __last; char* __p = __last;
unsigned __divisor = 64; unsigned __divisor = 64;
while (__value > __divisor) { while (__value > __divisor) {
unsigned __c = __value % __divisor; unsigned __c = __value % __divisor;
__value /= __divisor; __value /= __divisor;
__p -= 2; __p -= 2;
std::memcpy(__p, &__base_8_lut[2 * __c], 2); std::memcpy(__p, &__table<>::__base_8_lut[2 * __c], 2);
} }
do { do {
unsigned __c = __value % 8; unsigned __c = __value % 8;
__value /= 8; __value /= 8;
*--__p = "01234567"[__c]; *--__p = "01234567"[__c];
} while (__value != 0); } while (__value != 0);
return {__last, errc(0)}; return {__last, errc(0)};
} }
Show All 19 Lines _LIBCPP_HIDE_FROM_ABI static to_chars_result __to_chars(char* __first, char* __last, _Tp __value) {
__last = __first + __n; __last = __first + __n;
char* __p = __last; char* __p = __last;
unsigned __divisor = 256; unsigned __divisor = 256;
while (__value > __divisor) { while (__value > __divisor) {
unsigned __c = __value % __divisor; unsigned __c = __value % __divisor;
__value /= __divisor; __value /= __divisor;
__p -= 2; __p -= 2;
std::memcpy(__p, &__base_16_lut[2 * __c], 2); std::memcpy(__p, &__table<>::__base_16_lut[2 * __c], 2);
} }
if (__first != __last) if (__first != __last)
do { do {
unsigned __c = __value % 16; unsigned __c = __value % 16;
__value /= 16; __value /= 16;
*--__p = "0123456789abcdef"[__c]; *--__p = "0123456789abcdef"[__c];
} while (__value != 0); } while (__value != 0);
return {__last, errc(0)}; return {__last, errc(0)};
▲ Show 20 Lines • Show All 362 Lines • Show Last 20 Lines

libcxx/src/include/ryu/digit_table.h

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// A table of all two-digit numbers. This is used to speed up decimal digit // A table of all two-digit numbers. This is used to speed up decimal digit
// generation by copying pairs of digits into the final output. // generation by copying pairs of digits into the final output.
// //
// In order to minimize the diff in the Ryu code between MSVC STL and libc++ // In order to minimize the diff in the Ryu code between MSVC STL and libc++
// the code uses the name __DIGIT_TABLE. In order to avoid code duplication it // the code uses the name __DIGIT_TABLE. In order to avoid code duplication it
// reuses the table already available in libc++. // reuses the table already available in libc++.
inline constexpr auto& __DIGIT_TABLE = __itoa::__digits_base_10<>::__value; inline constexpr auto& __DIGIT_TABLE = __itoa::__table<>::__digits_base_10;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H #endif // _LIBCPP_SRC_INCLUDE_RYU_DIGIT_TABLE_H