mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
1957 lines
66 KiB
C
1957 lines
66 KiB
C
// Copyright 2020 The Wuffs Authors.
|
||
//
|
||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
// you may not use this file except in compliance with the License.
|
||
// You may obtain a copy of the License at
|
||
//
|
||
// https://www.apache.org/licenses/LICENSE-2.0
|
||
//
|
||
// 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.
|
||
|
||
// ---------------- IEEE 754 Floating Point
|
||
|
||
WUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u16 //
|
||
wuffs_base__ieee_754_bit_representation__from_f64_to_u16_truncate(double f) {
|
||
uint64_t u = 0;
|
||
if (sizeof(uint64_t) == sizeof(double)) {
|
||
memcpy(&u, &f, sizeof(uint64_t));
|
||
}
|
||
uint16_t neg = ((uint16_t)((u >> 63) << 15));
|
||
u &= 0x7FFFFFFFFFFFFFFF;
|
||
uint64_t exp = u >> 52;
|
||
uint64_t man = u & 0x000FFFFFFFFFFFFF;
|
||
|
||
if (exp == 0x7FF) {
|
||
if (man == 0) { // Infinity.
|
||
wuffs_base__lossy_value_u16 ret;
|
||
ret.value = neg | 0x7C00;
|
||
ret.lossy = false;
|
||
return ret;
|
||
}
|
||
// NaN. Shift the 52 mantissa bits to 10 mantissa bits, keeping the most
|
||
// significant mantissa bit (quiet vs signaling NaNs). Also set the low 9
|
||
// bits of ret.value so that the 10-bit mantissa is non-zero.
|
||
wuffs_base__lossy_value_u16 ret;
|
||
ret.value = neg | 0x7DFF | ((uint16_t)(man >> 42));
|
||
ret.lossy = false;
|
||
return ret;
|
||
|
||
} else if (exp > 0x40E) { // Truncate to the largest finite f16.
|
||
wuffs_base__lossy_value_u16 ret;
|
||
ret.value = neg | 0x7BFF;
|
||
ret.lossy = true;
|
||
return ret;
|
||
|
||
} else if (exp <= 0x3E6) { // Truncate to zero.
|
||
wuffs_base__lossy_value_u16 ret;
|
||
ret.value = neg;
|
||
ret.lossy = (u != 0);
|
||
return ret;
|
||
|
||
} else if (exp <= 0x3F0) { // Normal f64, subnormal f16.
|
||
// Convert from a 53-bit mantissa (after realizing the implicit bit) to a
|
||
// 10-bit mantissa and then adjust for the exponent.
|
||
man |= 0x0010000000000000;
|
||
uint32_t shift = ((uint32_t)(1051 - exp)); // 1051 = 0x3F0 + 53 - 10.
|
||
uint64_t shifted_man = man >> shift;
|
||
wuffs_base__lossy_value_u16 ret;
|
||
ret.value = neg | ((uint16_t)shifted_man);
|
||
ret.lossy = (shifted_man << shift) != man;
|
||
return ret;
|
||
}
|
||
|
||
// Normal f64, normal f16.
|
||
|
||
// Re-bias from 1023 to 15 and shift above f16's 10 mantissa bits.
|
||
exp = (exp - 1008) << 10; // 1008 = 1023 - 15 = 0x3FF - 0xF.
|
||
|
||
// Convert from a 52-bit mantissa (excluding the implicit bit) to a 10-bit
|
||
// mantissa (again excluding the implicit bit). We lose some information if
|
||
// any of the bottom 42 bits are non-zero.
|
||
wuffs_base__lossy_value_u16 ret;
|
||
ret.value = neg | ((uint16_t)exp) | ((uint16_t)(man >> 42));
|
||
ret.lossy = (man << 22) != 0;
|
||
return ret;
|
||
}
|
||
|
||
WUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u32 //
|
||
wuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) {
|
||
uint64_t u = 0;
|
||
if (sizeof(uint64_t) == sizeof(double)) {
|
||
memcpy(&u, &f, sizeof(uint64_t));
|
||
}
|
||
uint32_t neg = ((uint32_t)(u >> 63)) << 31;
|
||
u &= 0x7FFFFFFFFFFFFFFF;
|
||
uint64_t exp = u >> 52;
|
||
uint64_t man = u & 0x000FFFFFFFFFFFFF;
|
||
|
||
if (exp == 0x7FF) {
|
||
if (man == 0) { // Infinity.
|
||
wuffs_base__lossy_value_u32 ret;
|
||
ret.value = neg | 0x7F800000;
|
||
ret.lossy = false;
|
||
return ret;
|
||
}
|
||
// NaN. Shift the 52 mantissa bits to 23 mantissa bits, keeping the most
|
||
// significant mantissa bit (quiet vs signaling NaNs). Also set the low 22
|
||
// bits of ret.value so that the 23-bit mantissa is non-zero.
|
||
wuffs_base__lossy_value_u32 ret;
|
||
ret.value = neg | 0x7FBFFFFF | ((uint32_t)(man >> 29));
|
||
ret.lossy = false;
|
||
return ret;
|
||
|
||
} else if (exp > 0x47E) { // Truncate to the largest finite f32.
|
||
wuffs_base__lossy_value_u32 ret;
|
||
ret.value = neg | 0x7F7FFFFF;
|
||
ret.lossy = true;
|
||
return ret;
|
||
|
||
} else if (exp <= 0x369) { // Truncate to zero.
|
||
wuffs_base__lossy_value_u32 ret;
|
||
ret.value = neg;
|
||
ret.lossy = (u != 0);
|
||
return ret;
|
||
|
||
} else if (exp <= 0x380) { // Normal f64, subnormal f32.
|
||
// Convert from a 53-bit mantissa (after realizing the implicit bit) to a
|
||
// 23-bit mantissa and then adjust for the exponent.
|
||
man |= 0x0010000000000000;
|
||
uint32_t shift = ((uint32_t)(926 - exp)); // 926 = 0x380 + 53 - 23.
|
||
uint64_t shifted_man = man >> shift;
|
||
wuffs_base__lossy_value_u32 ret;
|
||
ret.value = neg | ((uint32_t)shifted_man);
|
||
ret.lossy = (shifted_man << shift) != man;
|
||
return ret;
|
||
}
|
||
|
||
// Normal f64, normal f32.
|
||
|
||
// Re-bias from 1023 to 127 and shift above f32's 23 mantissa bits.
|
||
exp = (exp - 896) << 23; // 896 = 1023 - 127 = 0x3FF - 0x7F.
|
||
|
||
// Convert from a 52-bit mantissa (excluding the implicit bit) to a 23-bit
|
||
// mantissa (again excluding the implicit bit). We lose some information if
|
||
// any of the bottom 29 bits are non-zero.
|
||
wuffs_base__lossy_value_u32 ret;
|
||
ret.value = neg | ((uint32_t)exp) | ((uint32_t)(man >> 29));
|
||
ret.lossy = (man << 35) != 0;
|
||
return ret;
|
||
}
|
||
|
||
// --------
|
||
|
||
#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 2047
|
||
#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 800
|
||
|
||
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL is the largest N
|
||
// such that ((10 << N) < (1 << 64)).
|
||
#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL 60
|
||
|
||
// wuffs_base__private_implementation__high_prec_dec (abbreviated as HPD) is a
|
||
// fixed precision floating point decimal number, augmented with ±infinity
|
||
// values, but it cannot represent NaN (Not a Number).
|
||
//
|
||
// "High precision" means that the mantissa holds 800 decimal digits. 800 is
|
||
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION.
|
||
//
|
||
// An HPD isn't for general purpose arithmetic, only for conversions to and
|
||
// from IEEE 754 double-precision floating point, where the largest and
|
||
// smallest positive, finite values are approximately 1.8e+308 and 4.9e-324.
|
||
// HPD exponents above +2047 mean infinity, below -2047 mean zero. The ±2047
|
||
// bounds are further away from zero than ±(324 + 800), where 800 and 2047 is
|
||
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION and
|
||
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.
|
||
//
|
||
// digits[.. num_digits] are the number's digits in big-endian order. The
|
||
// uint8_t values are in the range [0 ..= 9], not ['0' ..= '9'], where e.g. '7'
|
||
// is the ASCII value 0x37.
|
||
//
|
||
// decimal_point is the index (within digits) of the decimal point. It may be
|
||
// negative or be larger than num_digits, in which case the explicit digits are
|
||
// padded with implicit zeroes.
|
||
//
|
||
// For example, if num_digits is 3 and digits is "\x07\x08\x09":
|
||
// - A decimal_point of -2 means ".00789"
|
||
// - A decimal_point of -1 means ".0789"
|
||
// - A decimal_point of +0 means ".789"
|
||
// - A decimal_point of +1 means "7.89"
|
||
// - A decimal_point of +2 means "78.9"
|
||
// - A decimal_point of +3 means "789."
|
||
// - A decimal_point of +4 means "7890."
|
||
// - A decimal_point of +5 means "78900."
|
||
//
|
||
// As above, a decimal_point higher than +2047 means that the overall value is
|
||
// infinity, lower than -2047 means zero.
|
||
//
|
||
// negative is a sign bit. An HPD can distinguish positive and negative zero.
|
||
//
|
||
// truncated is whether there are more than
|
||
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION digits, and at
|
||
// least one of those extra digits are non-zero. The existence of long-tail
|
||
// digits can affect rounding.
|
||
//
|
||
// The "all fields are zero" value is valid, and represents the number +0.
|
||
typedef struct wuffs_base__private_implementation__high_prec_dec__struct {
|
||
uint32_t num_digits;
|
||
int32_t decimal_point;
|
||
bool negative;
|
||
bool truncated;
|
||
uint8_t digits[WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION];
|
||
} wuffs_base__private_implementation__high_prec_dec;
|
||
|
||
// wuffs_base__private_implementation__high_prec_dec__trim trims trailing
|
||
// zeroes from the h->digits[.. h->num_digits] slice. They have no benefit,
|
||
// since we explicitly track h->decimal_point.
|
||
//
|
||
// Preconditions:
|
||
// - h is non-NULL.
|
||
static inline void //
|
||
wuffs_base__private_implementation__high_prec_dec__trim(
|
||
wuffs_base__private_implementation__high_prec_dec* h) {
|
||
while ((h->num_digits > 0) && (h->digits[h->num_digits - 1] == 0)) {
|
||
h->num_digits--;
|
||
}
|
||
}
|
||
|
||
// wuffs_base__private_implementation__high_prec_dec__assign sets h to
|
||
// represent the number x.
|
||
//
|
||
// Preconditions:
|
||
// - h is non-NULL.
|
||
static void //
|
||
wuffs_base__private_implementation__high_prec_dec__assign(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
uint64_t x,
|
||
bool negative) {
|
||
uint32_t n = 0;
|
||
|
||
// Set h->digits.
|
||
if (x > 0) {
|
||
// Calculate the digits, working right-to-left. After we determine n (how
|
||
// many digits there are), copy from buf to h->digits.
|
||
//
|
||
// UINT64_MAX, 18446744073709551615, is 20 digits long. It can be faster to
|
||
// copy a constant number of bytes than a variable number (20 instead of
|
||
// n). Make buf large enough (and start writing to it from the middle) so
|
||
// that can we always copy 20 bytes: the slice buf[(20-n) .. (40-n)].
|
||
uint8_t buf[40] = {0};
|
||
uint8_t* ptr = &buf[20];
|
||
do {
|
||
uint64_t remaining = x / 10;
|
||
x -= remaining * 10;
|
||
ptr--;
|
||
*ptr = (uint8_t)x;
|
||
n++;
|
||
x = remaining;
|
||
} while (x > 0);
|
||
memcpy(h->digits, ptr, 20);
|
||
}
|
||
|
||
// Set h's other fields.
|
||
h->num_digits = n;
|
||
h->decimal_point = (int32_t)n;
|
||
h->negative = negative;
|
||
h->truncated = false;
|
||
wuffs_base__private_implementation__high_prec_dec__trim(h);
|
||
}
|
||
|
||
static wuffs_base__status //
|
||
wuffs_base__private_implementation__high_prec_dec__parse(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
wuffs_base__slice_u8 s,
|
||
uint32_t options) {
|
||
if (!h) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||
}
|
||
h->num_digits = 0;
|
||
h->decimal_point = 0;
|
||
h->negative = false;
|
||
h->truncated = false;
|
||
|
||
uint8_t* p = s.ptr;
|
||
uint8_t* q = s.ptr + s.len;
|
||
|
||
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
|
||
for (;; p++) {
|
||
if (p >= q) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
} else if (*p != '_') {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Parse sign.
|
||
do {
|
||
if (*p == '+') {
|
||
p++;
|
||
} else if (*p == '-') {
|
||
h->negative = true;
|
||
p++;
|
||
} else {
|
||
break;
|
||
}
|
||
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
|
||
for (;; p++) {
|
||
if (p >= q) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
} else if (*p != '_') {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
} while (0);
|
||
|
||
// Parse digits, up to (and including) a '.', 'E' or 'e'. Examples for each
|
||
// limb in this if-else chain:
|
||
// - "0.789"
|
||
// - "1002.789"
|
||
// - ".789"
|
||
// - Other (invalid input).
|
||
uint32_t nd = 0;
|
||
int32_t dp = 0;
|
||
bool no_digits_before_separator = false;
|
||
if (('0' == *p) &&
|
||
!(options &
|
||
WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES)) {
|
||
p++;
|
||
for (;; p++) {
|
||
if (p >= q) {
|
||
goto after_all;
|
||
} else if (*p ==
|
||
((options &
|
||
WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
|
||
? ','
|
||
: '.')) {
|
||
p++;
|
||
goto after_sep;
|
||
} else if ((*p == 'E') || (*p == 'e')) {
|
||
p++;
|
||
goto after_exp;
|
||
} else if ((*p != '_') ||
|
||
!(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
}
|
||
}
|
||
|
||
} else if (('0' <= *p) && (*p <= '9')) {
|
||
if (*p == '0') {
|
||
for (; (p < q) && (*p == '0'); p++) {
|
||
}
|
||
} else {
|
||
h->digits[nd++] = (uint8_t)(*p - '0');
|
||
dp = (int32_t)nd;
|
||
p++;
|
||
}
|
||
|
||
for (;; p++) {
|
||
if (p >= q) {
|
||
goto after_all;
|
||
} else if (('0' <= *p) && (*p <= '9')) {
|
||
if (nd < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {
|
||
h->digits[nd++] = (uint8_t)(*p - '0');
|
||
dp = (int32_t)nd;
|
||
} else if ('0' != *p) {
|
||
// Long-tail non-zeroes set the truncated bit.
|
||
h->truncated = true;
|
||
}
|
||
} else if (*p ==
|
||
((options &
|
||
WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
|
||
? ','
|
||
: '.')) {
|
||
p++;
|
||
goto after_sep;
|
||
} else if ((*p == 'E') || (*p == 'e')) {
|
||
p++;
|
||
goto after_exp;
|
||
} else if ((*p != '_') ||
|
||
!(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
}
|
||
}
|
||
|
||
} else if (*p == ((options &
|
||
WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
|
||
? ','
|
||
: '.')) {
|
||
p++;
|
||
no_digits_before_separator = true;
|
||
|
||
} else {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
}
|
||
|
||
after_sep:
|
||
for (;; p++) {
|
||
if (p >= q) {
|
||
goto after_all;
|
||
} else if ('0' == *p) {
|
||
if (nd == 0) {
|
||
// Track leading zeroes implicitly.
|
||
dp--;
|
||
} else if (nd <
|
||
WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {
|
||
h->digits[nd++] = (uint8_t)(*p - '0');
|
||
}
|
||
} else if (('0' < *p) && (*p <= '9')) {
|
||
if (nd < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {
|
||
h->digits[nd++] = (uint8_t)(*p - '0');
|
||
} else {
|
||
// Long-tail non-zeroes set the truncated bit.
|
||
h->truncated = true;
|
||
}
|
||
} else if ((*p == 'E') || (*p == 'e')) {
|
||
p++;
|
||
goto after_exp;
|
||
} else if ((*p != '_') ||
|
||
!(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
}
|
||
}
|
||
|
||
after_exp:
|
||
do {
|
||
if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {
|
||
for (;; p++) {
|
||
if (p >= q) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
} else if (*p != '_') {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
int32_t exp_sign = +1;
|
||
if (*p == '+') {
|
||
p++;
|
||
} else if (*p == '-') {
|
||
exp_sign = -1;
|
||
p++;
|
||
}
|
||
|
||
int32_t exp = 0;
|
||
const int32_t exp_large =
|
||
WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE +
|
||
WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;
|
||
bool saw_exp_digits = false;
|
||
for (; p < q; p++) {
|
||
if ((*p == '_') &&
|
||
(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {
|
||
// No-op.
|
||
} else if (('0' <= *p) && (*p <= '9')) {
|
||
saw_exp_digits = true;
|
||
if (exp < exp_large) {
|
||
exp = (10 * exp) + ((int32_t)(*p - '0'));
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
if (!saw_exp_digits) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
}
|
||
dp += exp_sign * exp;
|
||
} while (0);
|
||
|
||
after_all:
|
||
if (p != q) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
}
|
||
h->num_digits = nd;
|
||
if (nd == 0) {
|
||
if (no_digits_before_separator) {
|
||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||
}
|
||
h->decimal_point = 0;
|
||
} else if (dp <
|
||
-WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {
|
||
h->decimal_point =
|
||
-WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE - 1;
|
||
} else if (dp >
|
||
+WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {
|
||
h->decimal_point =
|
||
+WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE + 1;
|
||
} else {
|
||
h->decimal_point = dp;
|
||
}
|
||
wuffs_base__private_implementation__high_prec_dec__trim(h);
|
||
return wuffs_base__make_status(NULL);
|
||
}
|
||
|
||
// --------
|
||
|
||
// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits
|
||
// returns the number of additional decimal digits when left-shifting by shift.
|
||
//
|
||
// See below for preconditions.
|
||
static uint32_t //
|
||
wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
uint32_t shift) {
|
||
// Masking with 0x3F should be unnecessary (assuming the preconditions) but
|
||
// it's cheap and ensures that we don't overflow the
|
||
// wuffs_base__private_implementation__hpd_left_shift array.
|
||
shift &= 63;
|
||
|
||
uint32_t x_a = wuffs_base__private_implementation__hpd_left_shift[shift];
|
||
uint32_t x_b = wuffs_base__private_implementation__hpd_left_shift[shift + 1];
|
||
uint32_t num_new_digits = x_a >> 11;
|
||
uint32_t pow5_a = 0x7FF & x_a;
|
||
uint32_t pow5_b = 0x7FF & x_b;
|
||
|
||
const uint8_t* pow5 =
|
||
&wuffs_base__private_implementation__powers_of_5[pow5_a];
|
||
uint32_t i = 0;
|
||
uint32_t n = pow5_b - pow5_a;
|
||
for (; i < n; i++) {
|
||
if (i >= h->num_digits) {
|
||
return num_new_digits - 1;
|
||
} else if (h->digits[i] == pow5[i]) {
|
||
continue;
|
||
} else if (h->digits[i] < pow5[i]) {
|
||
return num_new_digits - 1;
|
||
} else {
|
||
return num_new_digits;
|
||
}
|
||
}
|
||
return num_new_digits;
|
||
}
|
||
|
||
// --------
|
||
|
||
// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns
|
||
// the integral (non-fractional) part of h, provided that it is 18 or fewer
|
||
// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:
|
||
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
|
||
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
|
||
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
|
||
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
|
||
// and that IEEE 754 double precision has 52 mantissa bits.
|
||
//
|
||
// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.
|
||
//
|
||
// h's negative bit is ignored: rounding -8.6 returns 9.
|
||
//
|
||
// See below for preconditions.
|
||
static uint64_t //
|
||
wuffs_base__private_implementation__high_prec_dec__rounded_integer(
|
||
wuffs_base__private_implementation__high_prec_dec* h) {
|
||
if ((h->num_digits == 0) || (h->decimal_point < 0)) {
|
||
return 0;
|
||
} else if (h->decimal_point > 18) {
|
||
return UINT64_MAX;
|
||
}
|
||
|
||
uint32_t dp = (uint32_t)(h->decimal_point);
|
||
uint64_t n = 0;
|
||
uint32_t i = 0;
|
||
for (; i < dp; i++) {
|
||
n = (10 * n) + ((i < h->num_digits) ? h->digits[i] : 0);
|
||
}
|
||
|
||
bool round_up = false;
|
||
if (dp < h->num_digits) {
|
||
round_up = h->digits[dp] >= 5;
|
||
if ((h->digits[dp] == 5) && (dp + 1 == h->num_digits)) {
|
||
// We are exactly halfway. If we're truncated, round up, otherwise round
|
||
// to even.
|
||
round_up = h->truncated || //
|
||
((dp > 0) && (1 & h->digits[dp - 1]));
|
||
}
|
||
}
|
||
if (round_up) {
|
||
n++;
|
||
}
|
||
|
||
return n;
|
||
}
|
||
|
||
// wuffs_base__private_implementation__high_prec_dec__small_xshift shifts h's
|
||
// number (where 'x' is 'l' or 'r' for left or right) by a small shift value.
|
||
//
|
||
// Preconditions:
|
||
// - h is non-NULL.
|
||
// - h->decimal_point is "not extreme".
|
||
// - shift is non-zero.
|
||
// - shift is "a small shift".
|
||
//
|
||
// "Not extreme" means within
|
||
// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.
|
||
//
|
||
// "A small shift" means not more than
|
||
// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL.
|
||
//
|
||
// wuffs_base__private_implementation__high_prec_dec__rounded_integer and
|
||
// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits
|
||
// have the same preconditions.
|
||
//
|
||
// wuffs_base__private_implementation__high_prec_dec__lshift keeps the first
|
||
// two preconditions but not the last two. Its shift argument is signed and
|
||
// does not need to be "small": zero is a no-op, positive means left shift and
|
||
// negative means right shift.
|
||
|
||
static void //
|
||
wuffs_base__private_implementation__high_prec_dec__small_lshift(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
uint32_t shift) {
|
||
if (h->num_digits == 0) {
|
||
return;
|
||
}
|
||
uint32_t num_new_digits =
|
||
wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(
|
||
h, shift);
|
||
uint32_t rx = h->num_digits - 1; // Read index.
|
||
uint32_t wx = h->num_digits - 1 + num_new_digits; // Write index.
|
||
uint64_t n = 0;
|
||
|
||
// Repeat: pick up a digit, put down a digit, right to left.
|
||
while (((int32_t)rx) >= 0) {
|
||
n += ((uint64_t)(h->digits[rx])) << shift;
|
||
uint64_t quo = n / 10;
|
||
uint64_t rem = n - (10 * quo);
|
||
if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {
|
||
h->digits[wx] = (uint8_t)rem;
|
||
} else if (rem > 0) {
|
||
h->truncated = true;
|
||
}
|
||
n = quo;
|
||
wx--;
|
||
rx--;
|
||
}
|
||
|
||
// Put down leading digits, right to left.
|
||
while (n > 0) {
|
||
uint64_t quo = n / 10;
|
||
uint64_t rem = n - (10 * quo);
|
||
if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {
|
||
h->digits[wx] = (uint8_t)rem;
|
||
} else if (rem > 0) {
|
||
h->truncated = true;
|
||
}
|
||
n = quo;
|
||
wx--;
|
||
}
|
||
|
||
// Finish.
|
||
h->num_digits += num_new_digits;
|
||
if (h->num_digits >
|
||
WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {
|
||
h->num_digits = WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;
|
||
}
|
||
h->decimal_point += (int32_t)num_new_digits;
|
||
wuffs_base__private_implementation__high_prec_dec__trim(h);
|
||
}
|
||
|
||
static void //
|
||
wuffs_base__private_implementation__high_prec_dec__small_rshift(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
uint32_t shift) {
|
||
uint32_t rx = 0; // Read index.
|
||
uint32_t wx = 0; // Write index.
|
||
uint64_t n = 0;
|
||
|
||
// Pick up enough leading digits to cover the first shift.
|
||
while ((n >> shift) == 0) {
|
||
if (rx < h->num_digits) {
|
||
// Read a digit.
|
||
n = (10 * n) + h->digits[rx++];
|
||
} else if (n == 0) {
|
||
// h's number used to be zero and remains zero.
|
||
return;
|
||
} else {
|
||
// Read sufficient implicit trailing zeroes.
|
||
while ((n >> shift) == 0) {
|
||
n = 10 * n;
|
||
rx++;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
h->decimal_point -= ((int32_t)(rx - 1));
|
||
if (h->decimal_point <
|
||
-WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {
|
||
// After the shift, h's number is effectively zero.
|
||
h->num_digits = 0;
|
||
h->decimal_point = 0;
|
||
h->truncated = false;
|
||
return;
|
||
}
|
||
|
||
// Repeat: pick up a digit, put down a digit, left to right.
|
||
uint64_t mask = (((uint64_t)(1)) << shift) - 1;
|
||
while (rx < h->num_digits) {
|
||
uint8_t new_digit = ((uint8_t)(n >> shift));
|
||
n = (10 * (n & mask)) + h->digits[rx++];
|
||
h->digits[wx++] = new_digit;
|
||
}
|
||
|
||
// Put down trailing digits, left to right.
|
||
while (n > 0) {
|
||
uint8_t new_digit = ((uint8_t)(n >> shift));
|
||
n = 10 * (n & mask);
|
||
if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {
|
||
h->digits[wx++] = new_digit;
|
||
} else if (new_digit > 0) {
|
||
h->truncated = true;
|
||
}
|
||
}
|
||
|
||
// Finish.
|
||
h->num_digits = wx;
|
||
wuffs_base__private_implementation__high_prec_dec__trim(h);
|
||
}
|
||
|
||
static void //
|
||
wuffs_base__private_implementation__high_prec_dec__lshift(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
int32_t shift) {
|
||
if (shift > 0) {
|
||
while (shift > +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {
|
||
wuffs_base__private_implementation__high_prec_dec__small_lshift(
|
||
h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);
|
||
shift -= WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
|
||
}
|
||
wuffs_base__private_implementation__high_prec_dec__small_lshift(
|
||
h, ((uint32_t)(+shift)));
|
||
} else if (shift < 0) {
|
||
while (shift < -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {
|
||
wuffs_base__private_implementation__high_prec_dec__small_rshift(
|
||
h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);
|
||
shift += WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
|
||
}
|
||
wuffs_base__private_implementation__high_prec_dec__small_rshift(
|
||
h, ((uint32_t)(-shift)));
|
||
}
|
||
}
|
||
|
||
// --------
|
||
|
||
// wuffs_base__private_implementation__high_prec_dec__round_etc rounds h's
|
||
// number. For those functions that take an n argument, rounding produces at
|
||
// most n digits (which is not necessarily at most n decimal places). Negative
|
||
// n values are ignored, as well as any n greater than or equal to h's number
|
||
// of digits. The etc__round_just_enough function implicitly chooses an n to
|
||
// implement WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION.
|
||
//
|
||
// Preconditions:
|
||
// - h is non-NULL.
|
||
// - h->decimal_point is "not extreme".
|
||
//
|
||
// "Not extreme" means within
|
||
// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.
|
||
|
||
static void //
|
||
wuffs_base__private_implementation__high_prec_dec__round_down(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
int32_t n) {
|
||
if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
|
||
return;
|
||
}
|
||
h->num_digits = (uint32_t)(n);
|
||
wuffs_base__private_implementation__high_prec_dec__trim(h);
|
||
}
|
||
|
||
static void //
|
||
wuffs_base__private_implementation__high_prec_dec__round_up(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
int32_t n) {
|
||
if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
|
||
return;
|
||
}
|
||
|
||
for (n--; n >= 0; n--) {
|
||
if (h->digits[n] < 9) {
|
||
h->digits[n]++;
|
||
h->num_digits = (uint32_t)(n + 1);
|
||
return;
|
||
}
|
||
}
|
||
|
||
// The number is all 9s. Change to a single 1 and adjust the decimal point.
|
||
h->digits[0] = 1;
|
||
h->num_digits = 1;
|
||
h->decimal_point++;
|
||
}
|
||
|
||
static void //
|
||
wuffs_base__private_implementation__high_prec_dec__round_nearest(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
int32_t n) {
|
||
if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
|
||
return;
|
||
}
|
||
bool up = h->digits[n] >= 5;
|
||
if ((h->digits[n] == 5) && ((n + 1) == ((int32_t)(h->num_digits)))) {
|
||
up = h->truncated || //
|
||
((n > 0) && ((h->digits[n - 1] & 1) != 0));
|
||
}
|
||
|
||
if (up) {
|
||
wuffs_base__private_implementation__high_prec_dec__round_up(h, n);
|
||
} else {
|
||
wuffs_base__private_implementation__high_prec_dec__round_down(h, n);
|
||
}
|
||
}
|
||
|
||
static void //
|
||
wuffs_base__private_implementation__high_prec_dec__round_just_enough(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
int32_t exp2,
|
||
uint64_t mantissa) {
|
||
// The magic numbers 52 and 53 in this function are because IEEE 754 double
|
||
// precision has 52 mantissa bits.
|
||
//
|
||
// Let f be the floating point number represented by exp2 and mantissa (and
|
||
// also the number in h): the number (mantissa * (2 ** (exp2 - 52))).
|
||
//
|
||
// If f is zero or a small integer, we can return early.
|
||
if ((mantissa == 0) ||
|
||
((exp2 < 53) && (h->decimal_point >= ((int32_t)(h->num_digits))))) {
|
||
return;
|
||
}
|
||
|
||
// The smallest normal f has an exp2 of -1022 and a mantissa of (1 << 52).
|
||
// Subnormal numbers have the same exp2 but a smaller mantissa.
|
||
static const int32_t min_incl_normal_exp2 = -1022;
|
||
static const uint64_t min_incl_normal_mantissa = 0x0010000000000000ul;
|
||
|
||
// Compute lower and upper bounds such that any number between them (possibly
|
||
// inclusive) will round to f. First, the lower bound. Our number f is:
|
||
// ((mantissa + 0) * (2 ** ( exp2 - 52)))
|
||
//
|
||
// The next lowest floating point number is:
|
||
// ((mantissa - 1) * (2 ** ( exp2 - 52)))
|
||
// unless (mantissa - 1) drops the (1 << 52) bit and exp2 is not the
|
||
// min_incl_normal_exp2. Either way, call it:
|
||
// ((l_mantissa) * (2 ** (l_exp2 - 52)))
|
||
//
|
||
// The lower bound is halfway between them (noting that 52 became 53):
|
||
// (((2 * l_mantissa) + 1) * (2 ** (l_exp2 - 53)))
|
||
int32_t l_exp2 = exp2;
|
||
uint64_t l_mantissa = mantissa - 1;
|
||
if ((exp2 > min_incl_normal_exp2) && (mantissa <= min_incl_normal_mantissa)) {
|
||
l_exp2 = exp2 - 1;
|
||
l_mantissa = (2 * mantissa) - 1;
|
||
}
|
||
wuffs_base__private_implementation__high_prec_dec lower;
|
||
wuffs_base__private_implementation__high_prec_dec__assign(
|
||
&lower, (2 * l_mantissa) + 1, false);
|
||
wuffs_base__private_implementation__high_prec_dec__lshift(&lower,
|
||
l_exp2 - 53);
|
||
|
||
// Next, the upper bound. Our number f is:
|
||
// ((mantissa + 0) * (2 ** (exp2 - 52)))
|
||
//
|
||
// The next highest floating point number is:
|
||
// ((mantissa + 1) * (2 ** (exp2 - 52)))
|
||
//
|
||
// The upper bound is halfway between them (noting that 52 became 53):
|
||
// (((2 * mantissa) + 1) * (2 ** (exp2 - 53)))
|
||
wuffs_base__private_implementation__high_prec_dec upper;
|
||
wuffs_base__private_implementation__high_prec_dec__assign(
|
||
&upper, (2 * mantissa) + 1, false);
|
||
wuffs_base__private_implementation__high_prec_dec__lshift(&upper, exp2 - 53);
|
||
|
||
// The lower and upper bounds are possible outputs only if the original
|
||
// mantissa is even, so that IEEE round-to-even would round to the original
|
||
// mantissa and not its neighbors.
|
||
bool inclusive = (mantissa & 1) == 0;
|
||
|
||
// As we walk the digits, we want to know whether rounding up would fall
|
||
// within the upper bound. This is tracked by upper_delta:
|
||
// - When -1, the digits of h and upper are the same so far.
|
||
// - When +0, we saw a difference of 1 between h and upper on a previous
|
||
// digit and subsequently only 9s for h and 0s for upper. Thus, rounding
|
||
// up may fall outside of the bound if !inclusive.
|
||
// - When +1, the difference is greater than 1 and we know that rounding up
|
||
// falls within the bound.
|
||
//
|
||
// This is a state machine with three states. The numerical value for each
|
||
// state (-1, +0 or +1) isn't important, other than their order.
|
||
int upper_delta = -1;
|
||
|
||
// We can now figure out the shortest number of digits required. Walk the
|
||
// digits until h has distinguished itself from lower or upper.
|
||
//
|
||
// The zi and zd variables are indexes and digits, for z in l (lower), h (the
|
||
// number) and u (upper).
|
||
//
|
||
// The lower, h and upper numbers may have their decimal points at different
|
||
// places. In this case, upper is the longest, so we iterate ui starting from
|
||
// 0 and iterate li and hi starting from either 0 or -1.
|
||
int32_t ui = 0;
|
||
for (;; ui++) {
|
||
// Calculate hd, the middle number's digit.
|
||
int32_t hi = ui - upper.decimal_point + h->decimal_point;
|
||
if (hi >= ((int32_t)(h->num_digits))) {
|
||
break;
|
||
}
|
||
uint8_t hd = (((uint32_t)hi) < h->num_digits) ? h->digits[hi] : 0;
|
||
|
||
// Calculate ld, the lower bound's digit.
|
||
int32_t li = ui - upper.decimal_point + lower.decimal_point;
|
||
uint8_t ld = (((uint32_t)li) < lower.num_digits) ? lower.digits[li] : 0;
|
||
|
||
// We can round down (truncate) if lower has a different digit than h or if
|
||
// lower is inclusive and is exactly the result of rounding down (i.e. we
|
||
// have reached the final digit of lower).
|
||
bool can_round_down =
|
||
(ld != hd) || //
|
||
(inclusive && ((li + 1) == ((int32_t)(lower.num_digits))));
|
||
|
||
// Calculate ud, the upper bound's digit, and update upper_delta.
|
||
uint8_t ud = (((uint32_t)ui) < upper.num_digits) ? upper.digits[ui] : 0;
|
||
if (upper_delta < 0) {
|
||
if ((hd + 1) < ud) {
|
||
// For example:
|
||
// h = 12345???
|
||
// upper = 12347???
|
||
upper_delta = +1;
|
||
} else if (hd != ud) {
|
||
// For example:
|
||
// h = 12345???
|
||
// upper = 12346???
|
||
upper_delta = +0;
|
||
}
|
||
} else if (upper_delta == 0) {
|
||
if ((hd != 9) || (ud != 0)) {
|
||
// For example:
|
||
// h = 1234598?
|
||
// upper = 1234600?
|
||
upper_delta = +1;
|
||
}
|
||
}
|
||
|
||
// We can round up if upper has a different digit than h and either upper
|
||
// is inclusive or upper is bigger than the result of rounding up.
|
||
bool can_round_up =
|
||
(upper_delta > 0) || //
|
||
((upper_delta == 0) && //
|
||
(inclusive || ((ui + 1) < ((int32_t)(upper.num_digits)))));
|
||
|
||
// If we can round either way, round to nearest. If we can round only one
|
||
// way, do it. If we can't round, continue the loop.
|
||
if (can_round_down) {
|
||
if (can_round_up) {
|
||
wuffs_base__private_implementation__high_prec_dec__round_nearest(
|
||
h, hi + 1);
|
||
return;
|
||
} else {
|
||
wuffs_base__private_implementation__high_prec_dec__round_down(h,
|
||
hi + 1);
|
||
return;
|
||
}
|
||
} else {
|
||
if (can_round_up) {
|
||
wuffs_base__private_implementation__high_prec_dec__round_up(h, hi + 1);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// --------
|
||
|
||
// wuffs_base__private_implementation__parse_number_f64_eisel_lemire produces
|
||
// the IEEE 754 double-precision value for an exact mantissa and base-10
|
||
// exponent. For example:
|
||
// - when parsing "12345.678e+02", man is 12345678 and exp10 is -1.
|
||
// - when parsing "-12", man is 12 and exp10 is 0. Processing the leading
|
||
// minus sign is the responsibility of the caller, not this function.
|
||
//
|
||
// On success, it returns a non-negative int64_t such that the low 63 bits hold
|
||
// the 11-bit exponent and 52-bit mantissa.
|
||
//
|
||
// On failure, it returns a negative value.
|
||
//
|
||
// The algorithm is based on an original idea by Michael Eisel that was refined
|
||
// by Daniel Lemire. See
|
||
// https://lemire.me/blog/2020/03/10/fast-float-parsing-in-practice/
|
||
// and
|
||
// https://nigeltao.github.io/blog/2020/eisel-lemire.html
|
||
//
|
||
// Preconditions:
|
||
// - man is non-zero.
|
||
// - exp10 is in the range [-307 ..= 288], the same range of the
|
||
// wuffs_base__private_implementation__powers_of_10 array.
|
||
//
|
||
// The exp10 range (and the fact that man is in the range [1 ..= UINT64_MAX],
|
||
// approximately [1 ..= 1.85e+19]) means that (man * (10 ** exp10)) is in the
|
||
// range [1e-307 ..= 1.85e+307]. This is entirely within the range of normal
|
||
// (neither subnormal nor non-finite) f64 values: DBL_MIN and DBL_MAX are
|
||
// approximately 2.23e–308 and 1.80e+308.
|
||
static int64_t //
|
||
wuffs_base__private_implementation__parse_number_f64_eisel_lemire(
|
||
uint64_t man,
|
||
int32_t exp10) {
|
||
// Look up the (possibly truncated) base-2 representation of (10 ** exp10).
|
||
// The look-up table was constructed so that it is already normalized: the
|
||
// table entry's mantissa's MSB (most significant bit) is on.
|
||
const uint64_t* po10 =
|
||
&wuffs_base__private_implementation__powers_of_10[exp10 + 307][0];
|
||
|
||
// Normalize the man argument. The (man != 0) precondition means that a
|
||
// non-zero bit exists.
|
||
uint32_t clz = wuffs_base__count_leading_zeroes_u64(man);
|
||
man <<= clz;
|
||
|
||
// Calculate the return value's base-2 exponent. We might tweak it by ±1
|
||
// later, but its initial value comes from a linear scaling of exp10,
|
||
// converting from power-of-10 to power-of-2, and adjusting by clz.
|
||
//
|
||
// The magic constants are:
|
||
// - 1087 = 1023 + 64. The 1023 is the f64 exponent bias. The 64 is because
|
||
// the look-up table uses 64-bit mantissas.
|
||
// - 217706 is such that the ratio 217706 / 65536 ≈ 3.321930 is close enough
|
||
// (over the practical range of exp10) to log(10) / log(2) ≈ 3.321928.
|
||
// - 65536 = 1<<16 is arbitrary but a power of 2, so division is a shift.
|
||
//
|
||
// Equality of the linearly-scaled value and the actual power-of-2, over the
|
||
// range of exp10 arguments that this function accepts, is confirmed by
|
||
// script/print-mpb-powers-of-10.go
|
||
uint64_t ret_exp2 =
|
||
((uint64_t)(((217706 * exp10) >> 16) + 1087)) - ((uint64_t)clz);
|
||
|
||
// Multiply the two mantissas. Normalization means that both mantissas are at
|
||
// least (1<<63), so the 128-bit product must be at least (1<<126). The high
|
||
// 64 bits of the product, x_hi, must therefore be at least (1<<62).
|
||
//
|
||
// As a consequence, x_hi has either 0 or 1 leading zeroes. Shifting x_hi
|
||
// right by either 9 or 10 bits (depending on x_hi's MSB) will therefore
|
||
// leave the top 10 MSBs (bits 54 ..= 63) off and the 11th MSB (bit 53) on.
|
||
wuffs_base__multiply_u64__output x = wuffs_base__multiply_u64(man, po10[1]);
|
||
uint64_t x_hi = x.hi;
|
||
uint64_t x_lo = x.lo;
|
||
|
||
// Before we shift right by at least 9 bits, recall that the look-up table
|
||
// entry was possibly truncated. We have so far only calculated a lower bound
|
||
// for the product (man * e), where e is (10 ** exp10). The upper bound would
|
||
// add a further (man * 1) to the 128-bit product, which overflows the lower
|
||
// 64-bit limb if ((x_lo + man) < man).
|
||
//
|
||
// If overflow occurs, that adds 1 to x_hi. Since we're about to shift right
|
||
// by at least 9 bits, that carried 1 can be ignored unless the higher 64-bit
|
||
// limb's low 9 bits are all on.
|
||
//
|
||
// For example, parsing "9999999999999999999" will take the if-true branch
|
||
// here, since:
|
||
// - x_hi = 0x4563918244F3FFFF
|
||
// - x_lo = 0x8000000000000000
|
||
// - man = 0x8AC7230489E7FFFF
|
||
if (((x_hi & 0x1FF) == 0x1FF) && ((x_lo + man) < man)) {
|
||
// Refine our calculation of (man * e). Before, our approximation of e used
|
||
// a "low resolution" 64-bit mantissa. Now use a "high resolution" 128-bit
|
||
// mantissa. We've already calculated x = (man * bits_0_to_63_incl_of_e).
|
||
// Now calculate y = (man * bits_64_to_127_incl_of_e).
|
||
wuffs_base__multiply_u64__output y = wuffs_base__multiply_u64(man, po10[0]);
|
||
uint64_t y_hi = y.hi;
|
||
uint64_t y_lo = y.lo;
|
||
|
||
// Merge the 128-bit x and 128-bit y, which overlap by 64 bits, to
|
||
// calculate the 192-bit product of the 64-bit man by the 128-bit e.
|
||
// As we exit this if-block, we only care about the high 128 bits
|
||
// (merged_hi and merged_lo) of that 192-bit product.
|
||
//
|
||
// For example, parsing "1.234e-45" will take the if-true branch here,
|
||
// since:
|
||
// - x_hi = 0x70B7E3696DB29FFF
|
||
// - x_lo = 0xE040000000000000
|
||
// - y_hi = 0x33718BBEAB0E0D7A
|
||
// - y_lo = 0xA880000000000000
|
||
uint64_t merged_hi = x_hi;
|
||
uint64_t merged_lo = x_lo + y_hi;
|
||
if (merged_lo < x_lo) {
|
||
merged_hi++; // Carry the overflow bit.
|
||
}
|
||
|
||
// The "high resolution" approximation of e is still a lower bound. Once
|
||
// again, see if the upper bound is large enough to produce a different
|
||
// result. This time, if it does, give up instead of reaching for an even
|
||
// more precise approximation to e.
|
||
//
|
||
// This three-part check is similar to the two-part check that guarded the
|
||
// if block that we're now in, but it has an extra term for the middle 64
|
||
// bits (checking that adding 1 to merged_lo would overflow).
|
||
//
|
||
// For example, parsing "5.9604644775390625e-8" will take the if-true
|
||
// branch here, since:
|
||
// - merged_hi = 0x7FFFFFFFFFFFFFFF
|
||
// - merged_lo = 0xFFFFFFFFFFFFFFFF
|
||
// - y_lo = 0x4DB3FFC120988200
|
||
// - man = 0xD3C21BCECCEDA100
|
||
if (((merged_hi & 0x1FF) == 0x1FF) && ((merged_lo + 1) == 0) &&
|
||
(y_lo + man < man)) {
|
||
return -1;
|
||
}
|
||
|
||
// Replace the 128-bit x with merged.
|
||
x_hi = merged_hi;
|
||
x_lo = merged_lo;
|
||
}
|
||
|
||
// As mentioned above, shifting x_hi right by either 9 or 10 bits will leave
|
||
// the top 10 MSBs (bits 54 ..= 63) off and the 11th MSB (bit 53) on. If the
|
||
// MSB (before shifting) was on, adjust ret_exp2 for the larger shift.
|
||
//
|
||
// Having bit 53 on (and higher bits off) means that ret_mantissa is a 54-bit
|
||
// number.
|
||
uint64_t msb = x_hi >> 63;
|
||
uint64_t ret_mantissa = x_hi >> (msb + 9);
|
||
ret_exp2 -= 1 ^ msb;
|
||
|
||
// IEEE 754 rounds to-nearest with ties rounded to-even. Rounding to-even can
|
||
// be tricky. If we're half-way between two exactly representable numbers
|
||
// (x's low 73 bits are zero and the next 2 bits that matter are "01"), give
|
||
// up instead of trying to pick the winner.
|
||
//
|
||
// Technically, we could tighten the condition by changing "73" to "73 or 74,
|
||
// depending on msb", but a flat "73" is simpler.
|
||
//
|
||
// For example, parsing "1e+23" will take the if-true branch here, since:
|
||
// - x_hi = 0x54B40B1F852BDA00
|
||
// - ret_mantissa = 0x002A5A058FC295ED
|
||
if ((x_lo == 0) && ((x_hi & 0x1FF) == 0) && ((ret_mantissa & 3) == 1)) {
|
||
return -1;
|
||
}
|
||
|
||
// If we're not halfway then it's rounding to-nearest. Starting with a 54-bit
|
||
// number, carry the lowest bit (bit 0) up if it's on. Regardless of whether
|
||
// it was on or off, shifting right by one then produces a 53-bit number. If
|
||
// carrying up overflowed, shift again.
|
||
ret_mantissa += ret_mantissa & 1;
|
||
ret_mantissa >>= 1;
|
||
// This if block is equivalent to (but benchmarks slightly faster than) the
|
||
// following branchless form:
|
||
// uint64_t overflow_adjustment = ret_mantissa >> 53;
|
||
// ret_mantissa >>= overflow_adjustment;
|
||
// ret_exp2 += overflow_adjustment;
|
||
//
|
||
// For example, parsing "7.2057594037927933e+16" will take the if-true
|
||
// branch here, since:
|
||
// - x_hi = 0x7FFFFFFFFFFFFE80
|
||
// - ret_mantissa = 0x0020000000000000
|
||
if ((ret_mantissa >> 53) > 0) {
|
||
ret_mantissa >>= 1;
|
||
ret_exp2++;
|
||
}
|
||
|
||
// Starting with a 53-bit number, IEEE 754 double-precision normal numbers
|
||
// have an implicit mantissa bit. Mask that away and keep the low 52 bits.
|
||
ret_mantissa &= 0x000FFFFFFFFFFFFF;
|
||
|
||
// Pack the bits and return.
|
||
return ((int64_t)(ret_mantissa | (ret_exp2 << 52)));
|
||
}
|
||
|
||
// --------
|
||
|
||
static wuffs_base__result_f64 //
|
||
wuffs_base__private_implementation__parse_number_f64_special(
|
||
wuffs_base__slice_u8 s,
|
||
uint32_t options) {
|
||
do {
|
||
if (options & WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN) {
|
||
goto fail;
|
||
}
|
||
|
||
uint8_t* p = s.ptr;
|
||
uint8_t* q = s.ptr + s.len;
|
||
|
||
for (; (p < q) && (*p == '_'); p++) {
|
||
}
|
||
if (p >= q) {
|
||
goto fail;
|
||
}
|
||
|
||
// Parse sign.
|
||
bool negative = false;
|
||
do {
|
||
if (*p == '+') {
|
||
p++;
|
||
} else if (*p == '-') {
|
||
negative = true;
|
||
p++;
|
||
} else {
|
||
break;
|
||
}
|
||
for (; (p < q) && (*p == '_'); p++) {
|
||
}
|
||
} while (0);
|
||
if (p >= q) {
|
||
goto fail;
|
||
}
|
||
|
||
bool nan = false;
|
||
switch (p[0]) {
|
||
case 'I':
|
||
case 'i':
|
||
if (((q - p) < 3) || //
|
||
((p[1] != 'N') && (p[1] != 'n')) || //
|
||
((p[2] != 'F') && (p[2] != 'f'))) {
|
||
goto fail;
|
||
}
|
||
p += 3;
|
||
|
||
if ((p >= q) || (*p == '_')) {
|
||
break;
|
||
} else if (((q - p) < 5) || //
|
||
((p[0] != 'I') && (p[0] != 'i')) || //
|
||
((p[1] != 'N') && (p[1] != 'n')) || //
|
||
((p[2] != 'I') && (p[2] != 'i')) || //
|
||
((p[3] != 'T') && (p[3] != 't')) || //
|
||
((p[4] != 'Y') && (p[4] != 'y'))) {
|
||
goto fail;
|
||
}
|
||
p += 5;
|
||
|
||
if ((p >= q) || (*p == '_')) {
|
||
break;
|
||
}
|
||
goto fail;
|
||
|
||
case 'N':
|
||
case 'n':
|
||
if (((q - p) < 3) || //
|
||
((p[1] != 'A') && (p[1] != 'a')) || //
|
||
((p[2] != 'N') && (p[2] != 'n'))) {
|
||
goto fail;
|
||
}
|
||
p += 3;
|
||
|
||
if ((p >= q) || (*p == '_')) {
|
||
nan = true;
|
||
break;
|
||
}
|
||
goto fail;
|
||
|
||
default:
|
||
goto fail;
|
||
}
|
||
|
||
// Finish.
|
||
for (; (p < q) && (*p == '_'); p++) {
|
||
}
|
||
if (p != q) {
|
||
goto fail;
|
||
}
|
||
wuffs_base__result_f64 ret;
|
||
ret.status.repr = NULL;
|
||
ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
||
(nan ? 0x7FFFFFFFFFFFFFFF : 0x7FF0000000000000) |
|
||
(negative ? 0x8000000000000000 : 0));
|
||
return ret;
|
||
} while (0);
|
||
|
||
fail:
|
||
do {
|
||
wuffs_base__result_f64 ret;
|
||
ret.status.repr = wuffs_base__error__bad_argument;
|
||
ret.value = 0;
|
||
return ret;
|
||
} while (0);
|
||
}
|
||
|
||
WUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 //
|
||
wuffs_base__private_implementation__high_prec_dec__to_f64(
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
uint32_t options) {
|
||
do {
|
||
// powers converts decimal powers of 10 to binary powers of 2. For example,
|
||
// (10000 >> 13) is 1. It stops before the elements exceed 60, also known
|
||
// as WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL.
|
||
static const uint32_t num_powers = 19;
|
||
static const uint8_t powers[19] = {
|
||
0, 3, 6, 9, 13, 16, 19, 23, 26, 29, //
|
||
33, 36, 39, 43, 46, 49, 53, 56, 59, //
|
||
};
|
||
|
||
// Handle zero and obvious extremes. The largest and smallest positive
|
||
// finite f64 values are approximately 1.8e+308 and 4.9e-324.
|
||
if ((h->num_digits == 0) || (h->decimal_point < -326)) {
|
||
goto zero;
|
||
} else if (h->decimal_point > 310) {
|
||
goto infinity;
|
||
}
|
||
|
||
// Try the fast Eisel-Lemire algorithm again. Calculating the (man, exp10)
|
||
// pair from the high_prec_dec h is more correct but slower than the
|
||
// approach taken in wuffs_base__parse_number_f64. The latter is optimized
|
||
// for the common cases (e.g. assuming no underscores or a leading '+'
|
||
// sign) rather than the full set of cases allowed by the Wuffs API.
|
||
if (h->num_digits <= 19) {
|
||
uint64_t man = 0;
|
||
uint32_t i;
|
||
for (i = 0; i < h->num_digits; i++) {
|
||
man = (10 * man) + h->digits[i];
|
||
}
|
||
int32_t exp10 = h->decimal_point - ((int32_t)(h->num_digits));
|
||
if ((man != 0) && (-307 <= exp10) && (exp10 <= 288)) {
|
||
int64_t r =
|
||
wuffs_base__private_implementation__parse_number_f64_eisel_lemire(
|
||
man, exp10);
|
||
if (r >= 0) {
|
||
wuffs_base__result_f64 ret;
|
||
ret.status.repr = NULL;
|
||
ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
||
((uint64_t)r) | (((uint64_t)(h->negative)) << 63));
|
||
return ret;
|
||
}
|
||
}
|
||
}
|
||
|
||
// When Eisel-Lemire fails, fall back to Simple Decimal Conversion. See
|
||
// https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html
|
||
//
|
||
// Scale by powers of 2 until we're in the range [½ .. 1], which gives us
|
||
// our exponent (in base-2). First we shift right, possibly a little too
|
||
// far, ending with a value certainly below 1 and possibly below ½...
|
||
const int32_t f64_bias = -1023;
|
||
int32_t exp2 = 0;
|
||
while (h->decimal_point > 0) {
|
||
uint32_t n = (uint32_t)(+h->decimal_point);
|
||
uint32_t shift =
|
||
(n < num_powers)
|
||
? powers[n]
|
||
: WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
|
||
|
||
wuffs_base__private_implementation__high_prec_dec__small_rshift(h, shift);
|
||
if (h->decimal_point <
|
||
-WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {
|
||
goto zero;
|
||
}
|
||
exp2 += (int32_t)shift;
|
||
}
|
||
// ...then we shift left, putting us in [½ .. 1].
|
||
while (h->decimal_point <= 0) {
|
||
uint32_t shift;
|
||
if (h->decimal_point == 0) {
|
||
if (h->digits[0] >= 5) {
|
||
break;
|
||
}
|
||
shift = (h->digits[0] < 2) ? 2 : 1;
|
||
} else {
|
||
uint32_t n = (uint32_t)(-h->decimal_point);
|
||
shift = (n < num_powers)
|
||
? powers[n]
|
||
: WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
|
||
}
|
||
|
||
wuffs_base__private_implementation__high_prec_dec__small_lshift(h, shift);
|
||
if (h->decimal_point >
|
||
+WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {
|
||
goto infinity;
|
||
}
|
||
exp2 -= (int32_t)shift;
|
||
}
|
||
|
||
// We're in the range [½ .. 1] but f64 uses [1 .. 2].
|
||
exp2--;
|
||
|
||
// The minimum normal exponent is (f64_bias + 1).
|
||
while ((f64_bias + 1) > exp2) {
|
||
uint32_t n = (uint32_t)((f64_bias + 1) - exp2);
|
||
if (n > WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {
|
||
n = WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
|
||
}
|
||
wuffs_base__private_implementation__high_prec_dec__small_rshift(h, n);
|
||
exp2 += (int32_t)n;
|
||
}
|
||
|
||
// Check for overflow.
|
||
if ((exp2 - f64_bias) >= 0x07FF) { // (1 << 11) - 1.
|
||
goto infinity;
|
||
}
|
||
|
||
// Extract 53 bits for the mantissa (in base-2).
|
||
wuffs_base__private_implementation__high_prec_dec__small_lshift(h, 53);
|
||
uint64_t man2 =
|
||
wuffs_base__private_implementation__high_prec_dec__rounded_integer(h);
|
||
|
||
// Rounding might have added one bit. If so, shift and re-check overflow.
|
||
if ((man2 >> 53) != 0) {
|
||
man2 >>= 1;
|
||
exp2++;
|
||
if ((exp2 - f64_bias) >= 0x07FF) { // (1 << 11) - 1.
|
||
goto infinity;
|
||
}
|
||
}
|
||
|
||
// Handle subnormal numbers.
|
||
if ((man2 >> 52) == 0) {
|
||
exp2 = f64_bias;
|
||
}
|
||
|
||
// Pack the bits and return.
|
||
uint64_t exp2_bits =
|
||
(uint64_t)((exp2 - f64_bias) & 0x07FF); // (1 << 11) - 1.
|
||
uint64_t bits = (man2 & 0x000FFFFFFFFFFFFF) | // (1 << 52) - 1.
|
||
(exp2_bits << 52) | //
|
||
(h->negative ? 0x8000000000000000 : 0); // (1 << 63).
|
||
|
||
wuffs_base__result_f64 ret;
|
||
ret.status.repr = NULL;
|
||
ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(bits);
|
||
return ret;
|
||
} while (0);
|
||
|
||
zero:
|
||
do {
|
||
uint64_t bits = h->negative ? 0x8000000000000000 : 0;
|
||
|
||
wuffs_base__result_f64 ret;
|
||
ret.status.repr = NULL;
|
||
ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(bits);
|
||
return ret;
|
||
} while (0);
|
||
|
||
infinity:
|
||
do {
|
||
if (options & WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN) {
|
||
wuffs_base__result_f64 ret;
|
||
ret.status.repr = wuffs_base__error__bad_argument;
|
||
ret.value = 0;
|
||
return ret;
|
||
}
|
||
|
||
uint64_t bits = h->negative ? 0xFFF0000000000000 : 0x7FF0000000000000;
|
||
|
||
wuffs_base__result_f64 ret;
|
||
ret.status.repr = NULL;
|
||
ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(bits);
|
||
return ret;
|
||
} while (0);
|
||
}
|
||
|
||
static inline bool //
|
||
wuffs_base__private_implementation__is_decimal_digit(uint8_t c) {
|
||
return ('0' <= c) && (c <= '9');
|
||
}
|
||
|
||
WUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 //
|
||
wuffs_base__parse_number_f64(wuffs_base__slice_u8 s, uint32_t options) {
|
||
// In practice, almost all "dd.ddddE±xxx" numbers can be represented
|
||
// losslessly by a uint64_t mantissa "dddddd" and an int32_t base-10
|
||
// exponent, adjusting "xxx" for the position (if present) of the decimal
|
||
// separator '.' or ','.
|
||
//
|
||
// This (u64 man, i32 exp10) data structure is superficially similar to the
|
||
// "Do It Yourself Floating Point" type from Loitsch (†), but the exponent
|
||
// here is base-10, not base-2.
|
||
//
|
||
// If s's number fits in a (man, exp10), parse that pair with the
|
||
// Eisel-Lemire algorithm. If not, or if Eisel-Lemire fails, parsing s with
|
||
// the fallback algorithm is slower but comprehensive.
|
||
//
|
||
// † "Printing Floating-Point Numbers Quickly and Accurately with Integers"
|
||
// (https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf).
|
||
// Florian Loitsch is also the primary contributor to
|
||
// https://github.com/google/double-conversion
|
||
do {
|
||
// Calculating that (man, exp10) pair needs to stay within s's bounds.
|
||
// Provided that s isn't extremely long, work on a NUL-terminated copy of
|
||
// s's contents. The NUL byte isn't a valid part of "±dd.ddddE±xxx".
|
||
//
|
||
// As the pointer p walks the contents, it's faster to repeatedly check "is
|
||
// *p a valid digit" than "is p within bounds and *p a valid digit".
|
||
if (s.len >= 256) {
|
||
goto fallback;
|
||
}
|
||
uint8_t z[256];
|
||
memcpy(&z[0], s.ptr, s.len);
|
||
z[s.len] = 0;
|
||
const uint8_t* p = &z[0];
|
||
|
||
// Look for a leading minus sign. Technically, we could also look for an
|
||
// optional plus sign, but the "script/process-json-numbers.c with -p"
|
||
// benchmark is noticably slower if we do. It's optional and, in practice,
|
||
// usually absent. Let the fallback catch it.
|
||
bool negative = (*p == '-');
|
||
if (negative) {
|
||
p++;
|
||
}
|
||
|
||
// After walking "dd.dddd", comparing p later with p now will produce the
|
||
// number of "d"s and "."s.
|
||
const uint8_t* const start_of_digits_ptr = p;
|
||
|
||
// Walk the "d"s before a '.', 'E', NUL byte, etc. If it starts with '0',
|
||
// it must be a single '0'. If it starts with a non-zero decimal digit, it
|
||
// can be a sequence of decimal digits.
|
||
//
|
||
// Update the man variable during the walk. It's OK if man overflows now.
|
||
// We'll detect that later.
|
||
uint64_t man;
|
||
if (*p == '0') {
|
||
man = 0;
|
||
p++;
|
||
if (wuffs_base__private_implementation__is_decimal_digit(*p)) {
|
||
goto fallback;
|
||
}
|
||
} else if (wuffs_base__private_implementation__is_decimal_digit(*p)) {
|
||
man = ((uint8_t)(*p - '0'));
|
||
p++;
|
||
for (; wuffs_base__private_implementation__is_decimal_digit(*p); p++) {
|
||
man = (10 * man) + ((uint8_t)(*p - '0'));
|
||
}
|
||
} else {
|
||
goto fallback;
|
||
}
|
||
|
||
// Walk the "d"s after the optional decimal separator ('.' or ','),
|
||
// updating the man and exp10 variables.
|
||
int32_t exp10 = 0;
|
||
if (*p ==
|
||
((options & WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
|
||
? ','
|
||
: '.')) {
|
||
p++;
|
||
const uint8_t* first_after_separator_ptr = p;
|
||
if (!wuffs_base__private_implementation__is_decimal_digit(*p)) {
|
||
goto fallback;
|
||
}
|
||
man = (10 * man) + ((uint8_t)(*p - '0'));
|
||
p++;
|
||
for (; wuffs_base__private_implementation__is_decimal_digit(*p); p++) {
|
||
man = (10 * man) + ((uint8_t)(*p - '0'));
|
||
}
|
||
exp10 = ((int32_t)(first_after_separator_ptr - p));
|
||
}
|
||
|
||
// Count the number of digits:
|
||
// - for an input of "314159", digit_count is 6.
|
||
// - for an input of "3.14159", digit_count is 7.
|
||
//
|
||
// This is off-by-one if there is a decimal separator. That's OK for now.
|
||
// We'll correct for that later. The "script/process-json-numbers.c with
|
||
// -p" benchmark is noticably slower if we try to correct for that now.
|
||
uint32_t digit_count = (uint32_t)(p - start_of_digits_ptr);
|
||
|
||
// Update exp10 for the optional exponent, starting with 'E' or 'e'.
|
||
if ((*p | 0x20) == 'e') {
|
||
p++;
|
||
int32_t exp_sign = +1;
|
||
if (*p == '-') {
|
||
p++;
|
||
exp_sign = -1;
|
||
} else if (*p == '+') {
|
||
p++;
|
||
}
|
||
if (!wuffs_base__private_implementation__is_decimal_digit(*p)) {
|
||
goto fallback;
|
||
}
|
||
int32_t exp_num = ((uint8_t)(*p - '0'));
|
||
p++;
|
||
// The rest of the exp_num walking has a peculiar control flow but, once
|
||
// again, the "script/process-json-numbers.c with -p" benchmark is
|
||
// sensitive to alternative formulations.
|
||
if (wuffs_base__private_implementation__is_decimal_digit(*p)) {
|
||
exp_num = (10 * exp_num) + ((uint8_t)(*p - '0'));
|
||
p++;
|
||
}
|
||
if (wuffs_base__private_implementation__is_decimal_digit(*p)) {
|
||
exp_num = (10 * exp_num) + ((uint8_t)(*p - '0'));
|
||
p++;
|
||
}
|
||
while (wuffs_base__private_implementation__is_decimal_digit(*p)) {
|
||
if (exp_num > 0x1000000) {
|
||
goto fallback;
|
||
}
|
||
exp_num = (10 * exp_num) + ((uint8_t)(*p - '0'));
|
||
p++;
|
||
}
|
||
exp10 += exp_sign * exp_num;
|
||
}
|
||
|
||
// The Wuffs API is that the original slice has no trailing data. It also
|
||
// allows underscores, which we don't catch here but the fallback should.
|
||
if (p != &z[s.len]) {
|
||
goto fallback;
|
||
}
|
||
|
||
// Check that the uint64_t typed man variable has not overflowed, based on
|
||
// digit_count.
|
||
//
|
||
// For reference:
|
||
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
|
||
// - (1 << 64) is 18446744073709551616, which has 20 decimal digits.
|
||
// - 19 nines, 9999999999999999999, is 0x8AC7230489E7FFFF, which has 64
|
||
// bits and 16 hexadecimal digits.
|
||
// - 20 nines, 99999999999999999999, is 0x56BC75E2D630FFFFF, which has 67
|
||
// bits and 17 hexadecimal digits.
|
||
if (digit_count > 19) {
|
||
// Even if we have more than 19 pseudo-digits, it's not yet definitely an
|
||
// overflow. Recall that digit_count might be off-by-one (too large) if
|
||
// there's a decimal separator. It will also over-report the number of
|
||
// meaningful digits if the input looks something like "0.000dddExxx".
|
||
//
|
||
// We adjust by the number of leading '0's and '.'s and re-compare to 19.
|
||
// Once again, technically, we could skip ','s too, but that perturbs the
|
||
// "script/process-json-numbers.c with -p" benchmark.
|
||
const uint8_t* q = start_of_digits_ptr;
|
||
for (; (*q == '0') || (*q == '.'); q++) {
|
||
}
|
||
digit_count -= (uint32_t)(q - start_of_digits_ptr);
|
||
if (digit_count > 19) {
|
||
goto fallback;
|
||
}
|
||
}
|
||
|
||
// The wuffs_base__private_implementation__parse_number_f64_eisel_lemire
|
||
// preconditions include that exp10 is in the range [-307 ..= 288].
|
||
if ((exp10 < -307) || (288 < exp10)) {
|
||
goto fallback;
|
||
}
|
||
|
||
// If both man and (10 ** exp10) are exactly representable by a double, we
|
||
// don't need to run the Eisel-Lemire algorithm.
|
||
if ((-22 <= exp10) && (exp10 <= 22) && ((man >> 53) == 0)) {
|
||
double d = (double)man;
|
||
if (exp10 >= 0) {
|
||
d *= wuffs_base__private_implementation__f64_powers_of_10[+exp10];
|
||
} else {
|
||
d /= wuffs_base__private_implementation__f64_powers_of_10[-exp10];
|
||
}
|
||
wuffs_base__result_f64 ret;
|
||
ret.status.repr = NULL;
|
||
ret.value = negative ? -d : +d;
|
||
return ret;
|
||
}
|
||
|
||
// The wuffs_base__private_implementation__parse_number_f64_eisel_lemire
|
||
// preconditions include that man is non-zero. Parsing "0" should be caught
|
||
// by the "If both man and (10 ** exp10)" above, but "0e99" might not.
|
||
if (man == 0) {
|
||
goto fallback;
|
||
}
|
||
|
||
// Our man and exp10 are in range. Run the Eisel-Lemire algorithm.
|
||
int64_t r =
|
||
wuffs_base__private_implementation__parse_number_f64_eisel_lemire(
|
||
man, exp10);
|
||
if (r < 0) {
|
||
goto fallback;
|
||
}
|
||
wuffs_base__result_f64 ret;
|
||
ret.status.repr = NULL;
|
||
ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
||
((uint64_t)r) | (((uint64_t)negative) << 63));
|
||
return ret;
|
||
} while (0);
|
||
|
||
fallback:
|
||
do {
|
||
wuffs_base__private_implementation__high_prec_dec h;
|
||
wuffs_base__status status =
|
||
wuffs_base__private_implementation__high_prec_dec__parse(&h, s,
|
||
options);
|
||
if (status.repr) {
|
||
return wuffs_base__private_implementation__parse_number_f64_special(
|
||
s, options);
|
||
}
|
||
return wuffs_base__private_implementation__high_prec_dec__to_f64(&h,
|
||
options);
|
||
} while (0);
|
||
}
|
||
|
||
// --------
|
||
|
||
static inline size_t //
|
||
wuffs_base__private_implementation__render_inf(wuffs_base__slice_u8 dst,
|
||
bool neg,
|
||
uint32_t options) {
|
||
if (neg) {
|
||
if (dst.len < 4) {
|
||
return 0;
|
||
}
|
||
wuffs_base__poke_u32le__no_bounds_check(dst.ptr, 0x666E492D); // '-Inf'le.
|
||
return 4;
|
||
}
|
||
|
||
if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
|
||
if (dst.len < 4) {
|
||
return 0;
|
||
}
|
||
wuffs_base__poke_u32le__no_bounds_check(dst.ptr, 0x666E492B); // '+Inf'le.
|
||
return 4;
|
||
}
|
||
|
||
if (dst.len < 3) {
|
||
return 0;
|
||
}
|
||
wuffs_base__poke_u24le__no_bounds_check(dst.ptr, 0x666E49); // 'Inf'le.
|
||
return 3;
|
||
}
|
||
|
||
static inline size_t //
|
||
wuffs_base__private_implementation__render_nan(wuffs_base__slice_u8 dst) {
|
||
if (dst.len < 3) {
|
||
return 0;
|
||
}
|
||
wuffs_base__poke_u24le__no_bounds_check(dst.ptr, 0x4E614E); // 'NaN'le.
|
||
return 3;
|
||
}
|
||
|
||
static size_t //
|
||
wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
|
||
wuffs_base__slice_u8 dst,
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
uint32_t precision,
|
||
uint32_t options) {
|
||
size_t n = (h->negative ||
|
||
(options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))
|
||
? 1
|
||
: 0;
|
||
if (h->decimal_point <= 0) {
|
||
n += 1;
|
||
} else {
|
||
n += (size_t)(h->decimal_point);
|
||
}
|
||
if (precision > 0) {
|
||
n += precision + 1; // +1 for the '.'.
|
||
}
|
||
|
||
// Don't modify dst if the formatted number won't fit.
|
||
if (n > dst.len) {
|
||
return 0;
|
||
}
|
||
|
||
// Align-left or align-right.
|
||
uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
|
||
? &dst.ptr[dst.len - n]
|
||
: &dst.ptr[0];
|
||
|
||
// Leading "±".
|
||
if (h->negative) {
|
||
*ptr++ = '-';
|
||
} else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
|
||
*ptr++ = '+';
|
||
}
|
||
|
||
// Integral digits.
|
||
if (h->decimal_point <= 0) {
|
||
*ptr++ = '0';
|
||
} else {
|
||
uint32_t m =
|
||
wuffs_base__u32__min(h->num_digits, (uint32_t)(h->decimal_point));
|
||
uint32_t i = 0;
|
||
for (; i < m; i++) {
|
||
*ptr++ = (uint8_t)('0' | h->digits[i]);
|
||
}
|
||
for (; i < (uint32_t)(h->decimal_point); i++) {
|
||
*ptr++ = '0';
|
||
}
|
||
}
|
||
|
||
// Separator and then fractional digits.
|
||
if (precision > 0) {
|
||
*ptr++ =
|
||
(options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
|
||
? ','
|
||
: '.';
|
||
uint32_t i = 0;
|
||
for (; i < precision; i++) {
|
||
uint32_t j = ((uint32_t)(h->decimal_point)) + i;
|
||
*ptr++ = (uint8_t)('0' | ((j < h->num_digits) ? h->digits[j] : 0));
|
||
}
|
||
}
|
||
|
||
return n;
|
||
}
|
||
|
||
static size_t //
|
||
wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
|
||
wuffs_base__slice_u8 dst,
|
||
wuffs_base__private_implementation__high_prec_dec* h,
|
||
uint32_t precision,
|
||
uint32_t options) {
|
||
int32_t exp = 0;
|
||
if (h->num_digits > 0) {
|
||
exp = h->decimal_point - 1;
|
||
}
|
||
bool negative_exp = exp < 0;
|
||
if (negative_exp) {
|
||
exp = -exp;
|
||
}
|
||
|
||
size_t n = (h->negative ||
|
||
(options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))
|
||
? 4
|
||
: 3; // Mininum 3 bytes: first digit and then "e±".
|
||
if (precision > 0) {
|
||
n += precision + 1; // +1 for the '.'.
|
||
}
|
||
n += (exp < 100) ? 2 : 3;
|
||
|
||
// Don't modify dst if the formatted number won't fit.
|
||
if (n > dst.len) {
|
||
return 0;
|
||
}
|
||
|
||
// Align-left or align-right.
|
||
uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
|
||
? &dst.ptr[dst.len - n]
|
||
: &dst.ptr[0];
|
||
|
||
// Leading "±".
|
||
if (h->negative) {
|
||
*ptr++ = '-';
|
||
} else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
|
||
*ptr++ = '+';
|
||
}
|
||
|
||
// Integral digit.
|
||
if (h->num_digits > 0) {
|
||
*ptr++ = (uint8_t)('0' | h->digits[0]);
|
||
} else {
|
||
*ptr++ = '0';
|
||
}
|
||
|
||
// Separator and then fractional digits.
|
||
if (precision > 0) {
|
||
*ptr++ =
|
||
(options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
|
||
? ','
|
||
: '.';
|
||
uint32_t i = 1;
|
||
uint32_t j = wuffs_base__u32__min(h->num_digits, precision + 1);
|
||
for (; i < j; i++) {
|
||
*ptr++ = (uint8_t)('0' | h->digits[i]);
|
||
}
|
||
for (; i <= precision; i++) {
|
||
*ptr++ = '0';
|
||
}
|
||
}
|
||
|
||
// Exponent: "e±" and then 2 or 3 digits.
|
||
*ptr++ = 'e';
|
||
*ptr++ = negative_exp ? '-' : '+';
|
||
if (exp < 10) {
|
||
*ptr++ = '0';
|
||
*ptr++ = (uint8_t)('0' | exp);
|
||
} else if (exp < 100) {
|
||
*ptr++ = (uint8_t)('0' | (exp / 10));
|
||
*ptr++ = (uint8_t)('0' | (exp % 10));
|
||
} else {
|
||
int32_t e = exp / 100;
|
||
exp -= e * 100;
|
||
*ptr++ = (uint8_t)('0' | e);
|
||
*ptr++ = (uint8_t)('0' | (exp / 10));
|
||
*ptr++ = (uint8_t)('0' | (exp % 10));
|
||
}
|
||
|
||
return n;
|
||
}
|
||
|
||
WUFFS_BASE__MAYBE_STATIC size_t //
|
||
wuffs_base__render_number_f64(wuffs_base__slice_u8 dst,
|
||
double x,
|
||
uint32_t precision,
|
||
uint32_t options) {
|
||
// Decompose x (64 bits) into negativity (1 bit), base-2 exponent (11 bits
|
||
// with a -1023 bias) and mantissa (52 bits).
|
||
uint64_t bits = wuffs_base__ieee_754_bit_representation__from_f64_to_u64(x);
|
||
bool neg = (bits >> 63) != 0;
|
||
int32_t exp2 = ((int32_t)(bits >> 52)) & 0x7FF;
|
||
uint64_t man = bits & 0x000FFFFFFFFFFFFFul;
|
||
|
||
// Apply the exponent bias and set the implicit top bit of the mantissa,
|
||
// unless x is subnormal. Also take care of Inf and NaN.
|
||
if (exp2 == 0x7FF) {
|
||
if (man != 0) {
|
||
return wuffs_base__private_implementation__render_nan(dst);
|
||
}
|
||
return wuffs_base__private_implementation__render_inf(dst, neg, options);
|
||
} else if (exp2 == 0) {
|
||
exp2 = -1022;
|
||
} else {
|
||
exp2 -= 1023;
|
||
man |= 0x0010000000000000ul;
|
||
}
|
||
|
||
// Ensure that precision isn't too large.
|
||
if (precision > 4095) {
|
||
precision = 4095;
|
||
}
|
||
|
||
// Convert from the (neg, exp2, man) tuple to an HPD.
|
||
wuffs_base__private_implementation__high_prec_dec h;
|
||
wuffs_base__private_implementation__high_prec_dec__assign(&h, man, neg);
|
||
if (h.num_digits > 0) {
|
||
wuffs_base__private_implementation__high_prec_dec__lshift(
|
||
&h, exp2 - 52); // 52 mantissa bits.
|
||
}
|
||
|
||
// Handle the "%e" and "%f" formats.
|
||
switch (options & (WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT |
|
||
WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT)) {
|
||
case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT: // The "%"f" format.
|
||
if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
|
||
wuffs_base__private_implementation__high_prec_dec__round_just_enough(
|
||
&h, exp2, man);
|
||
int32_t p = ((int32_t)(h.num_digits)) - h.decimal_point;
|
||
precision = ((uint32_t)(wuffs_base__i32__max(0, p)));
|
||
} else {
|
||
wuffs_base__private_implementation__high_prec_dec__round_nearest(
|
||
&h, ((int32_t)precision) + h.decimal_point);
|
||
}
|
||
return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
|
||
dst, &h, precision, options);
|
||
|
||
case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT: // The "%e" format.
|
||
if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
|
||
wuffs_base__private_implementation__high_prec_dec__round_just_enough(
|
||
&h, exp2, man);
|
||
precision = (h.num_digits > 0) ? (h.num_digits - 1) : 0;
|
||
} else {
|
||
wuffs_base__private_implementation__high_prec_dec__round_nearest(
|
||
&h, ((int32_t)precision) + 1);
|
||
}
|
||
return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
|
||
dst, &h, precision, options);
|
||
}
|
||
|
||
// We have the "%g" format and so precision means the number of significant
|
||
// digits, not the number of digits after the decimal separator. Perform
|
||
// rounding and determine whether to use "%e" or "%f".
|
||
int32_t e_threshold = 0;
|
||
if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
|
||
wuffs_base__private_implementation__high_prec_dec__round_just_enough(
|
||
&h, exp2, man);
|
||
precision = h.num_digits;
|
||
e_threshold = 6;
|
||
} else {
|
||
if (precision == 0) {
|
||
precision = 1;
|
||
}
|
||
wuffs_base__private_implementation__high_prec_dec__round_nearest(
|
||
&h, ((int32_t)precision));
|
||
e_threshold = ((int32_t)precision);
|
||
int32_t nd = ((int32_t)(h.num_digits));
|
||
if ((e_threshold > nd) && (nd >= h.decimal_point)) {
|
||
e_threshold = nd;
|
||
}
|
||
}
|
||
|
||
// Use the "%e" format if the exponent is large.
|
||
int32_t e = h.decimal_point - 1;
|
||
if ((e < -4) || (e_threshold <= e)) {
|
||
uint32_t p = wuffs_base__u32__min(precision, h.num_digits);
|
||
return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
|
||
dst, &h, (p > 0) ? (p - 1) : 0, options);
|
||
}
|
||
|
||
// Use the "%f" format otherwise.
|
||
int32_t p = ((int32_t)precision);
|
||
if (p > h.decimal_point) {
|
||
p = ((int32_t)(h.num_digits));
|
||
}
|
||
precision = ((uint32_t)(wuffs_base__i32__max(0, p - h.decimal_point)));
|
||
return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
|
||
dst, &h, precision, options);
|
||
}
|