20#ifndef RAPIDJSON_DTOA_
21#define RAPIDJSON_DTOA_
32RAPIDJSON_DIAG_OFF(effc++)
33RAPIDJSON_DIAG_OFF(array-bounds)
36inline void GrisuRound(
char* buffer,
int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
37 while (rest < wp_w && delta - rest >= ten_kappa &&
38 (rest + ten_kappa < wp_w ||
39 wp_w - rest > rest + ten_kappa - wp_w)) {
45inline int CountDecimalDigit32(uint32_t n) {
48 if (n < 100)
return 2;
49 if (n < 1000)
return 3;
50 if (n < 10000)
return 4;
51 if (n < 100000)
return 5;
52 if (n < 1000000)
return 6;
53 if (n < 10000000)
return 7;
54 if (n < 100000000)
return 8;
61inline void DigitGen(
const DiyFp& W,
const DiyFp& Mp, uint64_t delta,
char* buffer,
int* len,
int* K) {
62 static const uint64_t kPow10[] = { 1ULL, 10ULL, 100ULL, 1000ULL, 10000ULL, 100000ULL, 1000000ULL, 10000000ULL, 100000000ULL,
63 1000000000ULL, 10000000000ULL, 100000000000ULL, 1000000000000ULL,
64 10000000000000ULL, 100000000000000ULL, 1000000000000000ULL,
65 10000000000000000ULL, 100000000000000000ULL, 1000000000000000000ULL,
66 10000000000000000000ULL };
67 const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
68 const DiyFp wp_w = Mp - W;
69 uint32_t p1 =
static_cast<uint32_t
>(Mp.f >> -one.e);
70 uint64_t p2 = Mp.f & (one.f - 1);
71 int kappa = CountDecimalDigit32(p1);
77 case 9: d = p1 / 100000000; p1 %= 100000000;
break;
78 case 8: d = p1 / 10000000; p1 %= 10000000;
break;
79 case 7: d = p1 / 1000000; p1 %= 1000000;
break;
80 case 6: d = p1 / 100000; p1 %= 100000;
break;
81 case 5: d = p1 / 10000; p1 %= 10000;
break;
82 case 4: d = p1 / 1000; p1 %= 1000;
break;
83 case 3: d = p1 / 100; p1 %= 100;
break;
84 case 2: d = p1 / 10; p1 %= 10;
break;
85 case 1: d = p1; p1 = 0;
break;
89 buffer[(*len)++] =
static_cast<char>(
'0' +
static_cast<char>(d));
91 uint64_t tmp = (
static_cast<uint64_t
>(p1) << -one.e) + p2;
94 GrisuRound(buffer, *len, delta, tmp, kPow10[kappa] << -one.e, wp_w.f);
103 char d =
static_cast<char>(p2 >> -one.e);
105 buffer[(*len)++] =
static_cast<char>(
'0' + d);
111 GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 20 ? kPow10[index] : 0));
117inline void Grisu2(
double value,
char* buffer,
int* length,
int* K) {
118 const DiyFp v(value);
120 v.NormalizedBoundaries(&w_m, &w_p);
122 const DiyFp c_mk = GetCachedPower(w_p.e, K);
123 const DiyFp W = v.Normalize() * c_mk;
124 DiyFp Wp = w_p * c_mk;
125 DiyFp Wm = w_m * c_mk;
128 DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
131inline char* WriteExponent(
int K,
char* buffer) {
138 *buffer++ =
static_cast<char>(
'0' +
static_cast<char>(K / 100));
140 const char* d = GetDigitsLut() + K * 2;
145 const char* d = GetDigitsLut() + K * 2;
150 *buffer++ =
static_cast<char>(
'0' +
static_cast<char>(K));
155inline char* Prettify(
char* buffer,
int length,
int k,
int maxDecimalPlaces) {
156 const int kk = length + k;
158 if (0 <= k && kk <= 21) {
160 for (
int i = length; i < kk; i++)
163 buffer[kk + 1] =
'0';
164 return &buffer[kk + 2];
166 else if (0 < kk && kk <= 21) {
168 std::memmove(&buffer[kk + 1], &buffer[kk],
static_cast<size_t>(length - kk));
170 if (0 > k + maxDecimalPlaces) {
173 for (
int i = kk + maxDecimalPlaces; i > kk + 1; i--)
174 if (buffer[i] !=
'0')
175 return &buffer[i + 1];
176 return &buffer[kk + 2];
179 return &buffer[length + 1];
181 else if (-6 < kk && kk <= 0) {
183 const int offset = 2 - kk;
184 std::memmove(&buffer[offset], &buffer[0],
static_cast<size_t>(length));
187 for (
int i = 2; i < offset; i++)
189 if (length - kk > maxDecimalPlaces) {
192 for (
int i = maxDecimalPlaces + 1; i > 2; i--)
193 if (buffer[i] !=
'0')
194 return &buffer[i + 1];
198 return &buffer[length + offset];
200 else if (kk < -maxDecimalPlaces) {
207 else if (length == 1) {
210 return WriteExponent(kk - 1, &buffer[2]);
214 std::memmove(&buffer[2], &buffer[1],
static_cast<size_t>(length - 1));
216 buffer[length + 1] =
'e';
217 return WriteExponent(kk - 1, &buffer[0 + length + 2]);
221inline char* dtoa(
double value,
char* buffer,
int maxDecimalPlaces = 324) {
238 Grisu2(value, buffer, &length, &K);
239 return Prettify(buffer, length, K, maxDecimalPlaces);
#define RAPIDJSON_ASSERT(x)
Assertion.
#define RAPIDJSON_NAMESPACE_BEGIN
provide custom rapidjson namespace (opening expression)
#define RAPIDJSON_NAMESPACE_END
provide custom rapidjson namespace (closing expression)
Integer len(const char *s)
Retourne la longueur de la chaîne s.