Coverage Report

Created: 2024-09-23 06:29

/src/abseil-cpp/absl/strings/internal/charconv_parse.cc
Line
Count
Source (jump to first uncovered line)
1
// Copyright 2018 The Abseil Authors.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14
15
#include "absl/strings/internal/charconv_parse.h"
16
#include "absl/strings/charconv.h"
17
18
#include <cassert>
19
#include <cstdint>
20
#include <limits>
21
22
#include "absl/strings/internal/memutil.h"
23
24
namespace absl {
25
ABSL_NAMESPACE_BEGIN
26
namespace {
27
28
// ParseFloat<10> will read the first 19 significant digits of the mantissa.
29
// This number was chosen for multiple reasons.
30
//
31
// (a) First, for whatever integer type we choose to represent the mantissa, we
32
// want to choose the largest possible number of decimal digits for that integer
33
// type.  We are using uint64_t, which can express any 19-digit unsigned
34
// integer.
35
//
36
// (b) Second, we need to parse enough digits that the binary value of any
37
// mantissa we capture has more bits of resolution than the mantissa
38
// representation in the target float.  Our algorithm requires at least 3 bits
39
// of headway, but 19 decimal digits give a little more than that.
40
//
41
// The following static assertions verify the above comments:
42
constexpr int kDecimalMantissaDigitsMax = 19;
43
44
static_assert(std::numeric_limits<uint64_t>::digits10 ==
45
                  kDecimalMantissaDigitsMax,
46
              "(a) above");
47
48
// IEEE doubles, which we assume in Abseil, have 53 binary bits of mantissa.
49
static_assert(std::numeric_limits<double>::is_iec559, "IEEE double assumed");
50
static_assert(std::numeric_limits<double>::radix == 2, "IEEE double fact");
51
static_assert(std::numeric_limits<double>::digits == 53, "IEEE double fact");
52
53
// The lowest valued 19-digit decimal mantissa we can read still contains
54
// sufficient information to reconstruct a binary mantissa.
55
static_assert(1000000000000000000u > (uint64_t{1} << (53 + 3)), "(b) above");
56
57
// ParseFloat<16> will read the first 15 significant digits of the mantissa.
58
//
59
// Because a base-16-to-base-2 conversion can be done exactly, we do not need
60
// to maximize the number of scanned hex digits to improve our conversion.  What
61
// is required is to scan two more bits than the mantissa can represent, so that
62
// we always round correctly.
63
//
64
// (One extra bit does not suffice to perform correct rounding, since a number
65
// exactly halfway between two representable floats has unique rounding rules,
66
// so we need to differentiate between a "halfway between" number and a "closer
67
// to the larger value" number.)
68
constexpr int kHexadecimalMantissaDigitsMax = 15;
69
70
// The minimum number of significant bits that will be read from
71
// kHexadecimalMantissaDigitsMax hex digits.  We must subtract by three, since
72
// the most significant digit can be a "1", which only contributes a single
73
// significant bit.
74
constexpr int kGuaranteedHexadecimalMantissaBitPrecision =
75
    4 * kHexadecimalMantissaDigitsMax - 3;
76
77
static_assert(kGuaranteedHexadecimalMantissaBitPrecision >
78
                  std::numeric_limits<double>::digits + 2,
79
              "kHexadecimalMantissaDigitsMax too small");
80
81
// We also impose a limit on the number of significant digits we will read from
82
// an exponent, to avoid having to deal with integer overflow.  We use 9 for
83
// this purpose.
84
//
85
// If we read a 9 digit exponent, the end result of the conversion will
86
// necessarily be infinity or zero, depending on the sign of the exponent.
87
// Therefore we can just drop extra digits on the floor without any extra
88
// logic.
89
constexpr int kDecimalExponentDigitsMax = 9;
90
static_assert(std::numeric_limits<int>::digits10 >= kDecimalExponentDigitsMax,
91
              "int type too small");
92
93
// To avoid incredibly large inputs causing integer overflow for our exponent,
94
// we impose an arbitrary but very large limit on the number of significant
95
// digits we will accept.  The implementation refuses to match a string with
96
// more consecutive significant mantissa digits than this.
97
constexpr int kDecimalDigitLimit = 50000000;
98
99
// Corresponding limit for hexadecimal digit inputs.  This is one fourth the
100
// amount of kDecimalDigitLimit, since each dropped hexadecimal digit requires
101
// a binary exponent adjustment of 4.
102
constexpr int kHexadecimalDigitLimit = kDecimalDigitLimit / 4;
103
104
// The largest exponent we can read is 999999999 (per
105
// kDecimalExponentDigitsMax), and the largest exponent adjustment we can get
106
// from dropped mantissa digits is 2 * kDecimalDigitLimit, and the sum of these
107
// comfortably fits in an integer.
108
//
109
// We count kDecimalDigitLimit twice because there are independent limits for
110
// numbers before and after the decimal point.  (In the case where there are no
111
// significant digits before the decimal point, there are independent limits for
112
// post-decimal-point leading zeroes and for significant digits.)
113
static_assert(999999999 + 2 * kDecimalDigitLimit <
114
                  std::numeric_limits<int>::max(),
115
              "int type too small");
116
static_assert(999999999 + 2 * (4 * kHexadecimalDigitLimit) <
117
                  std::numeric_limits<int>::max(),
118
              "int type too small");
119
120
// Returns true if the provided bitfield allows parsing an exponent value
121
// (e.g., "1.5e100").
122
12.4M
bool AllowExponent(chars_format flags) {
123
12.4M
  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
124
12.4M
  bool scientific =
125
12.4M
      (flags & chars_format::scientific) == chars_format::scientific;
126
12.4M
  return scientific || !fixed;
127
12.4M
}
128
129
// Returns true if the provided bitfield requires an exponent value be present.
130
10.9M
bool RequireExponent(chars_format flags) {
131
10.9M
  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
132
10.9M
  bool scientific =
133
10.9M
      (flags & chars_format::scientific) == chars_format::scientific;
134
10.9M
  return scientific && !fixed;
135
10.9M
}
136
137
const int8_t kAsciiToInt[256] = {
138
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
139
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
140
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,
141
    9,  -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1,
142
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
143
    -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
144
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
145
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
146
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
147
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
148
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
149
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
150
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
151
    -1, -1, -1, -1, -1, -1, -1, -1, -1};
152
153
// Returns true if `ch` is a digit in the given base
154
template <int base>
155
bool IsDigit(char ch);
156
157
// Converts a valid `ch` to its digit value in the given base.
158
template <int base>
159
unsigned ToDigit(char ch);
160
161
// Returns true if `ch` is the exponent delimiter for the given base.
162
template <int base>
163
bool IsExponentCharacter(char ch);
164
165
// Returns the maximum number of significant digits we will read for a float
166
// in the given base.
167
template <int base>
168
constexpr int MantissaDigitsMax();
169
170
// Returns the largest consecutive run of digits we will accept when parsing a
171
// number in the given base.
172
template <int base>
173
constexpr int DigitLimit();
174
175
// Returns the amount the exponent must be adjusted by for each dropped digit.
176
// (For decimal this is 1, since the digits are in base 10 and the exponent base
177
// is also 10, but for hexadecimal this is 4, since the digits are base 16 but
178
// the exponent base is 2.)
179
template <int base>
180
constexpr int DigitMagnitude();
181
182
template <>
183
39.5M
bool IsDigit<10>(char ch) {
184
39.5M
  return ch >= '0' && ch <= '9';
185
39.5M
}
186
template <>
187
5.00M
bool IsDigit<16>(char ch) {
188
5.00M
  return kAsciiToInt[static_cast<unsigned char>(ch)] >= 0;
189
5.00M
}
190
191
template <>
192
19.9M
unsigned ToDigit<10>(char ch) {
193
19.9M
  return static_cast<unsigned>(ch - '0');
194
19.9M
}
195
template <>
196
21.4k
unsigned ToDigit<16>(char ch) {
197
21.4k
  return static_cast<unsigned>(kAsciiToInt[static_cast<unsigned char>(ch)]);
198
21.4k
}
199
200
template <>
201
1.48M
bool IsExponentCharacter<10>(char ch) {
202
1.48M
  return ch == 'e' || ch == 'E';
203
1.48M
}
204
205
template <>
206
2.57k
bool IsExponentCharacter<16>(char ch) {
207
2.57k
  return ch == 'p' || ch == 'P';
208
2.57k
}
209
210
template <>
211
37.3M
constexpr int MantissaDigitsMax<10>() {
212
37.3M
  return kDecimalMantissaDigitsMax;
213
37.3M
}
214
template <>
215
15.4k
constexpr int MantissaDigitsMax<16>() {
216
15.4k
  return kHexadecimalMantissaDigitsMax;
217
15.4k
}
218
219
template <>
220
12.4M
constexpr int DigitLimit<10>() {
221
12.4M
  return kDecimalDigitLimit;
222
12.4M
}
223
template <>
224
7.17k
constexpr int DigitLimit<16>() {
225
7.17k
  return kHexadecimalDigitLimit;
226
7.17k
}
227
228
template <>
229
11.8M
constexpr int DigitMagnitude<10>() {
230
11.8M
  return 1;
231
11.8M
}
232
template <>
233
4.41k
constexpr int DigitMagnitude<16>() {
234
4.41k
  return 4;
235
4.41k
}
236
237
// Reads decimal digits from [begin, end) into *out.  Returns the number of
238
// digits consumed.
239
//
240
// After max_digits has been read, keeps consuming characters, but no longer
241
// adjusts *out.  If a nonzero digit is dropped this way, *dropped_nonzero_digit
242
// is set; otherwise, it is left unmodified.
243
//
244
// If no digits are matched, returns 0 and leaves *out unchanged.
245
//
246
// ConsumeDigits does not protect against overflow on *out; max_digits must
247
// be chosen with respect to type T to avoid the possibility of overflow.
248
template <int base, typename T>
249
int ConsumeDigits(const char* begin, const char* end, int max_digits, T* out,
250
13.9M
                  bool* dropped_nonzero_digit) {
251
13.9M
  if (base == 10) {
252
13.9M
    assert(max_digits <= std::numeric_limits<T>::digits10);
253
13.9M
  } else if (base == 16) {
254
6.61k
    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
255
6.61k
  }
256
13.9M
  const char* const original_begin = begin;
257
258
  // Skip leading zeros, but only if *out is zero.
259
  // They don't cause an overflow so we don't have to count them for
260
  // `max_digits`.
261
14.3M
  while (!*out && end != begin && *begin == '0') ++begin;
262
263
13.9M
  T accumulator = *out;
264
13.9M
  const char* significant_digits_end =
265
13.9M
      (end - begin > max_digits) ? begin + max_digits : end;
266
33.9M
  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
267
    // Do not guard against *out overflow; max_digits was chosen to avoid this.
268
    // Do assert against it, to detect problems in debug builds.
269
20.0M
    auto digit = static_cast<T>(ToDigit<base>(*begin));
270
20.0M
    assert(accumulator * base >= accumulator);
271
20.0M
    accumulator *= base;
272
20.0M
    assert(accumulator + digit >= accumulator);
273
20.0M
    accumulator += digit;
274
20.0M
    ++begin;
275
20.0M
  }
276
13.9M
  bool dropped_nonzero = false;
277
35.4M
  while (begin < end && IsDigit<base>(*begin)) {
278
21.5M
    dropped_nonzero = dropped_nonzero || (*begin != '0');
279
21.5M
    ++begin;
280
21.5M
  }
281
13.9M
  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
282
14.5k
    *dropped_nonzero_digit = true;
283
14.5k
  }
284
13.9M
  *out = accumulator;
285
13.9M
  return static_cast<int>(begin - original_begin);
286
13.9M
}
charconv_parse.cc:int absl::(anonymous namespace)::ConsumeDigits<10, unsigned long>(char const*, char const*, int, unsigned long*, bool*)
Line
Count
Source
250
12.4M
                  bool* dropped_nonzero_digit) {
251
12.4M
  if (base == 10) {
252
12.4M
    assert(max_digits <= std::numeric_limits<T>::digits10);
253
12.4M
  } else if (base == 16) {
254
0
    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
255
0
  }
256
12.4M
  const char* const original_begin = begin;
257
258
  // Skip leading zeros, but only if *out is zero.
259
  // They don't cause an overflow so we don't have to count them for
260
  // `max_digits`.
261
12.4M
  while (!*out && end != begin && *begin == '0') ++begin;
262
263
12.4M
  T accumulator = *out;
264
12.4M
  const char* significant_digits_end =
265
12.4M
      (end - begin > max_digits) ? begin + max_digits : end;
266
29.4M
  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
267
    // Do not guard against *out overflow; max_digits was chosen to avoid this.
268
    // Do assert against it, to detect problems in debug builds.
269
17.0M
    auto digit = static_cast<T>(ToDigit<base>(*begin));
270
17.0M
    assert(accumulator * base >= accumulator);
271
17.0M
    accumulator *= base;
272
17.0M
    assert(accumulator + digit >= accumulator);
273
17.0M
    accumulator += digit;
274
17.0M
    ++begin;
275
17.0M
  }
276
12.4M
  bool dropped_nonzero = false;
277
24.4M
  while (begin < end && IsDigit<base>(*begin)) {
278
11.9M
    dropped_nonzero = dropped_nonzero || (*begin != '0');
279
11.9M
    ++begin;
280
11.9M
  }
281
12.4M
  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
282
13.7k
    *dropped_nonzero_digit = true;
283
13.7k
  }
284
12.4M
  *out = accumulator;
285
12.4M
  return static_cast<int>(begin - original_begin);
286
12.4M
}
charconv_parse.cc:int absl::(anonymous namespace)::ConsumeDigits<10, int>(char const*, char const*, int, int*, bool*)
Line
Count
Source
250
1.48M
                  bool* dropped_nonzero_digit) {
251
1.48M
  if (base == 10) {
252
1.48M
    assert(max_digits <= std::numeric_limits<T>::digits10);
253
1.48M
  } else if (base == 16) {
254
0
    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
255
0
  }
256
1.48M
  const char* const original_begin = begin;
257
258
  // Skip leading zeros, but only if *out is zero.
259
  // They don't cause an overflow so we don't have to count them for
260
  // `max_digits`.
261
1.88M
  while (!*out && end != begin && *begin == '0') ++begin;
262
263
1.48M
  T accumulator = *out;
264
1.48M
  const char* significant_digits_end =
265
1.48M
      (end - begin > max_digits) ? begin + max_digits : end;
266
4.46M
  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
267
    // Do not guard against *out overflow; max_digits was chosen to avoid this.
268
    // Do assert against it, to detect problems in debug builds.
269
2.98M
    auto digit = static_cast<T>(ToDigit<base>(*begin));
270
2.98M
    assert(accumulator * base >= accumulator);
271
2.98M
    accumulator *= base;
272
2.98M
    assert(accumulator + digit >= accumulator);
273
2.98M
    accumulator += digit;
274
2.98M
    ++begin;
275
2.98M
  }
276
1.48M
  bool dropped_nonzero = false;
277
6.08M
  while (begin < end && IsDigit<base>(*begin)) {
278
4.60M
    dropped_nonzero = dropped_nonzero || (*begin != '0');
279
4.60M
    ++begin;
280
4.60M
  }
281
1.48M
  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
282
0
    *dropped_nonzero_digit = true;
283
0
  }
284
1.48M
  *out = accumulator;
285
1.48M
  return static_cast<int>(begin - original_begin);
286
1.48M
}
charconv_parse.cc:int absl::(anonymous namespace)::ConsumeDigits<16, unsigned long>(char const*, char const*, int, unsigned long*, bool*)
Line
Count
Source
250
6.61k
                  bool* dropped_nonzero_digit) {
251
6.61k
  if (base == 10) {
252
0
    assert(max_digits <= std::numeric_limits<T>::digits10);
253
6.61k
  } else if (base == 16) {
254
6.61k
    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
255
6.61k
  }
256
6.61k
  const char* const original_begin = begin;
257
258
  // Skip leading zeros, but only if *out is zero.
259
  // They don't cause an overflow so we don't have to count them for
260
  // `max_digits`.
261
6.61k
  while (!*out && end != begin && *begin == '0') ++begin;
262
263
6.61k
  T accumulator = *out;
264
6.61k
  const char* significant_digits_end =
265
6.61k
      (end - begin > max_digits) ? begin + max_digits : end;
266
28.0k
  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
267
    // Do not guard against *out overflow; max_digits was chosen to avoid this.
268
    // Do assert against it, to detect problems in debug builds.
269
21.4k
    auto digit = static_cast<T>(ToDigit<base>(*begin));
270
21.4k
    assert(accumulator * base >= accumulator);
271
21.4k
    accumulator *= base;
272
21.4k
    assert(accumulator + digit >= accumulator);
273
21.4k
    accumulator += digit;
274
21.4k
    ++begin;
275
21.4k
  }
276
6.61k
  bool dropped_nonzero = false;
277
4.98M
  while (begin < end && IsDigit<base>(*begin)) {
278
4.97M
    dropped_nonzero = dropped_nonzero || (*begin != '0');
279
4.97M
    ++begin;
280
4.97M
  }
281
6.61k
  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
282
795
    *dropped_nonzero_digit = true;
283
795
  }
284
6.61k
  *out = accumulator;
285
6.61k
  return static_cast<int>(begin - original_begin);
286
6.61k
}
287
288
// Returns true if `v` is one of the chars allowed inside parentheses following
289
// a NaN.
290
2.86M
bool IsNanChar(char v) {
291
2.86M
  return (v == '_') || (v >= '0' && v <= '9') || (v >= 'a' && v <= 'z') ||
292
2.86M
         (v >= 'A' && v <= 'Z');
293
2.86M
}
294
295
// Checks the range [begin, end) for a strtod()-formatted infinity or NaN.  If
296
// one is found, sets `out` appropriately and returns true.
297
bool ParseInfinityOrNan(const char* begin, const char* end,
298
12.4M
                        strings_internal::ParsedFloat* out) {
299
12.4M
  if (end - begin < 3) {
300
9.78M
    return false;
301
9.78M
  }
302
2.68M
  switch (*begin) {
303
426
    case 'i':
304
791
    case 'I': {
305
      // An infinity string consists of the characters "inf" or "infinity",
306
      // case insensitive.
307
791
      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
308
23
        return false;
309
23
      }
310
768
      out->type = strings_internal::FloatType::kInfinity;
311
768
      if (end - begin >= 8 &&
312
768
          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
313
230
        out->end = begin + 8;
314
538
      } else {
315
538
        out->end = begin + 3;
316
538
      }
317
768
      return true;
318
791
    }
319
1.16k
    case 'n':
320
1.38k
    case 'N': {
321
      // A NaN consists of the characters "nan", case insensitive, optionally
322
      // followed by a parenthesized sequence of zero or more alphanumeric
323
      // characters and/or underscores.
324
1.38k
      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
325
24
        return false;
326
24
      }
327
1.35k
      out->type = strings_internal::FloatType::kNan;
328
1.35k
      out->end = begin + 3;
329
      // NaN is allowed to be followed by a parenthesized string, consisting of
330
      // only the characters [a-zA-Z0-9_].  Match that if it's present.
331
1.35k
      begin += 3;
332
1.35k
      if (begin < end && *begin == '(') {
333
749
        const char* nan_begin = begin + 1;
334
2.86M
        while (nan_begin < end && IsNanChar(*nan_begin)) {
335
2.86M
          ++nan_begin;
336
2.86M
        }
337
749
        if (nan_begin < end && *nan_begin == ')') {
338
          // We found an extra NaN specifier range
339
693
          out->subrange_begin = begin + 1;
340
693
          out->subrange_end = nan_begin;
341
693
          out->end = nan_begin + 1;
342
693
        }
343
749
      }
344
1.35k
      return true;
345
1.38k
    }
346
2.68M
    default:
347
2.68M
      return false;
348
2.68M
  }
349
2.68M
}
350
}  // namespace
351
352
namespace strings_internal {
353
354
template <int base>
355
strings_internal::ParsedFloat ParseFloat(const char* begin, const char* end,
356
12.4M
                                         chars_format format_flags) {
357
12.4M
  strings_internal::ParsedFloat result;
358
359
  // Exit early if we're given an empty range.
360
12.4M
  if (begin == end) return result;
361
362
  // Handle the infinity and NaN cases.
363
12.4M
  if (ParseInfinityOrNan(begin, end, &result)) {
364
2.12k
    return result;
365
2.12k
  }
366
367
12.4M
  const char* const mantissa_begin = begin;
368
13.4M
  while (begin < end && *begin == '0') {
369
990k
    ++begin;  // skip leading zeros
370
990k
  }
371
12.4M
  uint64_t mantissa = 0;
372
373
12.4M
  int exponent_adjustment = 0;
374
12.4M
  bool mantissa_is_inexact = false;
375
12.4M
  int pre_decimal_digits = ConsumeDigits<base>(
376
12.4M
      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
377
12.4M
  begin += pre_decimal_digits;
378
12.4M
  int digits_left;
379
12.4M
  if (pre_decimal_digits >= DigitLimit<base>()) {
380
    // refuse to parse pathological inputs
381
0
    return result;
382
12.4M
  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
383
    // We dropped some non-fraction digits on the floor.  Adjust our exponent
384
    // to compensate.
385
6.21k
    exponent_adjustment =
386
6.21k
        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
387
6.21k
    digits_left = 0;
388
12.4M
  } else {
389
12.4M
    digits_left =
390
12.4M
        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
391
12.4M
  }
392
12.4M
  if (begin < end && *begin == '.') {
393
14.4k
    ++begin;
394
14.4k
    if (mantissa == 0) {
395
      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
396
      // have to adjust the exponent to reflect the changed place value.
397
6.33k
      const char* begin_zeros = begin;
398
3.42M
      while (begin < end && *begin == '0') {
399
3.41M
        ++begin;
400
3.41M
      }
401
6.33k
      int zeros_skipped = static_cast<int>(begin - begin_zeros);
402
6.33k
      if (zeros_skipped >= DigitLimit<base>()) {
403
        // refuse to parse pathological inputs
404
0
        return result;
405
0
      }
406
6.33k
      exponent_adjustment -= static_cast<int>(zeros_skipped);
407
6.33k
    }
408
14.4k
    int post_decimal_digits = ConsumeDigits<base>(
409
14.4k
        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
410
14.4k
    begin += post_decimal_digits;
411
412
    // Since `mantissa` is an integer, each significant digit we read after
413
    // the decimal point requires an adjustment to the exponent. "1.23e0" will
414
    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
415
    // "123e-2").
416
14.4k
    if (post_decimal_digits >= DigitLimit<base>()) {
417
      // refuse to parse pathological inputs
418
0
      return result;
419
14.4k
    } else if (post_decimal_digits > digits_left) {
420
8.89k
      exponent_adjustment -= digits_left;
421
8.89k
    } else {
422
5.52k
      exponent_adjustment -= post_decimal_digits;
423
5.52k
    }
424
14.4k
  }
425
  // If we've found no mantissa whatsoever, this isn't a number.
426
12.4M
  if (mantissa_begin == begin) {
427
141
    return result;
428
141
  }
429
  // A bare "." doesn't count as a mantissa either.
430
12.4M
  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
431
20
    return result;
432
20
  }
433
434
12.4M
  if (mantissa_is_inexact) {
435
    // We dropped significant digits on the floor.  Handle this appropriately.
436
13.9k
    if (base == 10) {
437
      // If we truncated significant decimal digits, store the full range of the
438
      // mantissa for future big integer math for exact rounding.
439
13.2k
      result.subrange_begin = mantissa_begin;
440
13.2k
      result.subrange_end = begin;
441
13.2k
    } else if (base == 16) {
442
      // If we truncated hex digits, reflect this fact by setting the low
443
      // ("sticky") bit.  This allows for correct rounding in all cases.
444
676
      mantissa |= 1;
445
676
    }
446
13.9k
  }
447
12.4M
  result.mantissa = mantissa;
448
449
12.4M
  const char* const exponent_begin = begin;
450
12.4M
  result.literal_exponent = 0;
451
12.4M
  bool found_exponent = false;
452
12.4M
  if (AllowExponent(format_flags) && begin < end &&
453
12.4M
      IsExponentCharacter<base>(*begin)) {
454
1.48M
    bool negative_exponent = false;
455
1.48M
    ++begin;
456
1.48M
    if (begin < end && *begin == '-') {
457
11.4k
      negative_exponent = true;
458
11.4k
      ++begin;
459
1.47M
    } else if (begin < end && *begin == '+') {
460
536
      ++begin;
461
536
    }
462
1.48M
    const char* const exponent_digits_begin = begin;
463
    // Exponent is always expressed in decimal, even for hexadecimal floats.
464
1.48M
    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
465
1.48M
                               &result.literal_exponent, nullptr);
466
1.48M
    if (begin == exponent_digits_begin) {
467
      // there were no digits where we expected an exponent.  We failed to read
468
      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
469
75
      found_exponent = false;
470
75
      begin = exponent_begin;
471
1.48M
    } else {
472
1.48M
      found_exponent = true;
473
1.48M
      if (negative_exponent) {
474
11.4k
        result.literal_exponent = -result.literal_exponent;
475
11.4k
      }
476
1.48M
    }
477
1.48M
  }
478
479
12.4M
  if (!found_exponent && RequireExponent(format_flags)) {
480
    // Provided flags required an exponent, but none was found.  This results
481
    // in a failure to scan.
482
0
    return result;
483
0
  }
484
485
  // Success!
486
12.4M
  result.type = strings_internal::FloatType::kNumber;
487
12.4M
  if (result.mantissa > 0) {
488
11.8M
    result.exponent = result.literal_exponent +
489
11.8M
                      (DigitMagnitude<base>() * exponent_adjustment);
490
11.8M
  } else {
491
644k
    result.exponent = 0;
492
644k
  }
493
12.4M
  result.end = begin;
494
12.4M
  return result;
495
12.4M
}
absl::strings_internal::ParsedFloat absl::strings_internal::ParseFloat<10>(char const*, char const*, absl::chars_format)
Line
Count
Source
356
12.4M
                                         chars_format format_flags) {
357
12.4M
  strings_internal::ParsedFloat result;
358
359
  // Exit early if we're given an empty range.
360
12.4M
  if (begin == end) return result;
361
362
  // Handle the infinity and NaN cases.
363
12.4M
  if (ParseInfinityOrNan(begin, end, &result)) {
364
2.12k
    return result;
365
2.12k
  }
366
367
12.4M
  const char* const mantissa_begin = begin;
368
13.4M
  while (begin < end && *begin == '0') {
369
987k
    ++begin;  // skip leading zeros
370
987k
  }
371
12.4M
  uint64_t mantissa = 0;
372
373
12.4M
  int exponent_adjustment = 0;
374
12.4M
  bool mantissa_is_inexact = false;
375
12.4M
  int pre_decimal_digits = ConsumeDigits<base>(
376
12.4M
      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
377
12.4M
  begin += pre_decimal_digits;
378
12.4M
  int digits_left;
379
12.4M
  if (pre_decimal_digits >= DigitLimit<base>()) {
380
    // refuse to parse pathological inputs
381
0
    return result;
382
12.4M
  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
383
    // We dropped some non-fraction digits on the floor.  Adjust our exponent
384
    // to compensate.
385
5.80k
    exponent_adjustment =
386
5.80k
        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
387
5.80k
    digits_left = 0;
388
12.4M
  } else {
389
12.4M
    digits_left =
390
12.4M
        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
391
12.4M
  }
392
12.4M
  if (begin < end && *begin == '.') {
393
12.9k
    ++begin;
394
12.9k
    if (mantissa == 0) {
395
      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
396
      // have to adjust the exponent to reflect the changed place value.
397
5.77k
      const char* begin_zeros = begin;
398
3.40M
      while (begin < end && *begin == '0') {
399
3.40M
        ++begin;
400
3.40M
      }
401
5.77k
      int zeros_skipped = static_cast<int>(begin - begin_zeros);
402
5.77k
      if (zeros_skipped >= DigitLimit<base>()) {
403
        // refuse to parse pathological inputs
404
0
        return result;
405
0
      }
406
5.77k
      exponent_adjustment -= static_cast<int>(zeros_skipped);
407
5.77k
    }
408
12.9k
    int post_decimal_digits = ConsumeDigits<base>(
409
12.9k
        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
410
12.9k
    begin += post_decimal_digits;
411
412
    // Since `mantissa` is an integer, each significant digit we read after
413
    // the decimal point requires an adjustment to the exponent. "1.23e0" will
414
    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
415
    // "123e-2").
416
12.9k
    if (post_decimal_digits >= DigitLimit<base>()) {
417
      // refuse to parse pathological inputs
418
0
      return result;
419
12.9k
    } else if (post_decimal_digits > digits_left) {
420
8.41k
      exponent_adjustment -= digits_left;
421
8.41k
    } else {
422
4.52k
      exponent_adjustment -= post_decimal_digits;
423
4.52k
    }
424
12.9k
  }
425
  // If we've found no mantissa whatsoever, this isn't a number.
426
12.4M
  if (mantissa_begin == begin) {
427
125
    return result;
428
125
  }
429
  // A bare "." doesn't count as a mantissa either.
430
12.4M
  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
431
14
    return result;
432
14
  }
433
434
12.4M
  if (mantissa_is_inexact) {
435
    // We dropped significant digits on the floor.  Handle this appropriately.
436
13.2k
    if (base == 10) {
437
      // If we truncated significant decimal digits, store the full range of the
438
      // mantissa for future big integer math for exact rounding.
439
13.2k
      result.subrange_begin = mantissa_begin;
440
13.2k
      result.subrange_end = begin;
441
13.2k
    } else if (base == 16) {
442
      // If we truncated hex digits, reflect this fact by setting the low
443
      // ("sticky") bit.  This allows for correct rounding in all cases.
444
0
      mantissa |= 1;
445
0
    }
446
13.2k
  }
447
12.4M
  result.mantissa = mantissa;
448
449
12.4M
  const char* const exponent_begin = begin;
450
12.4M
  result.literal_exponent = 0;
451
12.4M
  bool found_exponent = false;
452
12.4M
  if (AllowExponent(format_flags) && begin < end &&
453
12.4M
      IsExponentCharacter<base>(*begin)) {
454
1.47M
    bool negative_exponent = false;
455
1.47M
    ++begin;
456
1.47M
    if (begin < end && *begin == '-') {
457
9.98k
      negative_exponent = true;
458
9.98k
      ++begin;
459
1.47M
    } else if (begin < end && *begin == '+') {
460
270
      ++begin;
461
270
    }
462
1.47M
    const char* const exponent_digits_begin = begin;
463
    // Exponent is always expressed in decimal, even for hexadecimal floats.
464
1.47M
    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
465
1.47M
                               &result.literal_exponent, nullptr);
466
1.47M
    if (begin == exponent_digits_begin) {
467
      // there were no digits where we expected an exponent.  We failed to read
468
      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
469
54
      found_exponent = false;
470
54
      begin = exponent_begin;
471
1.47M
    } else {
472
1.47M
      found_exponent = true;
473
1.47M
      if (negative_exponent) {
474
9.98k
        result.literal_exponent = -result.literal_exponent;
475
9.98k
      }
476
1.47M
    }
477
1.47M
  }
478
479
12.4M
  if (!found_exponent && RequireExponent(format_flags)) {
480
    // Provided flags required an exponent, but none was found.  This results
481
    // in a failure to scan.
482
0
    return result;
483
0
  }
484
485
  // Success!
486
12.4M
  result.type = strings_internal::FloatType::kNumber;
487
12.4M
  if (result.mantissa > 0) {
488
11.8M
    result.exponent = result.literal_exponent +
489
11.8M
                      (DigitMagnitude<base>() * exponent_adjustment);
490
11.8M
  } else {
491
643k
    result.exponent = 0;
492
643k
  }
493
12.4M
  result.end = begin;
494
12.4M
  return result;
495
12.4M
}
absl::strings_internal::ParsedFloat absl::strings_internal::ParseFloat<16>(char const*, char const*, absl::chars_format)
Line
Count
Source
356
5.15k
                                         chars_format format_flags) {
357
5.15k
  strings_internal::ParsedFloat result;
358
359
  // Exit early if we're given an empty range.
360
5.15k
  if (begin == end) return result;
361
362
  // Handle the infinity and NaN cases.
363
5.14k
  if (ParseInfinityOrNan(begin, end, &result)) {
364
1
    return result;
365
1
  }
366
367
5.14k
  const char* const mantissa_begin = begin;
368
7.80k
  while (begin < end && *begin == '0') {
369
2.65k
    ++begin;  // skip leading zeros
370
2.65k
  }
371
5.14k
  uint64_t mantissa = 0;
372
373
5.14k
  int exponent_adjustment = 0;
374
5.14k
  bool mantissa_is_inexact = false;
375
5.14k
  int pre_decimal_digits = ConsumeDigits<base>(
376
5.14k
      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
377
5.14k
  begin += pre_decimal_digits;
378
5.14k
  int digits_left;
379
5.14k
  if (pre_decimal_digits >= DigitLimit<base>()) {
380
    // refuse to parse pathological inputs
381
0
    return result;
382
5.14k
  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
383
    // We dropped some non-fraction digits on the floor.  Adjust our exponent
384
    // to compensate.
385
413
    exponent_adjustment =
386
413
        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
387
413
    digits_left = 0;
388
4.73k
  } else {
389
4.73k
    digits_left =
390
4.73k
        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
391
4.73k
  }
392
5.14k
  if (begin < end && *begin == '.') {
393
1.46k
    ++begin;
394
1.46k
    if (mantissa == 0) {
395
      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
396
      // have to adjust the exponent to reflect the changed place value.
397
565
      const char* begin_zeros = begin;
398
14.8k
      while (begin < end && *begin == '0') {
399
14.2k
        ++begin;
400
14.2k
      }
401
565
      int zeros_skipped = static_cast<int>(begin - begin_zeros);
402
565
      if (zeros_skipped >= DigitLimit<base>()) {
403
        // refuse to parse pathological inputs
404
0
        return result;
405
0
      }
406
565
      exponent_adjustment -= static_cast<int>(zeros_skipped);
407
565
    }
408
1.46k
    int post_decimal_digits = ConsumeDigits<base>(
409
1.46k
        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
410
1.46k
    begin += post_decimal_digits;
411
412
    // Since `mantissa` is an integer, each significant digit we read after
413
    // the decimal point requires an adjustment to the exponent. "1.23e0" will
414
    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
415
    // "123e-2").
416
1.46k
    if (post_decimal_digits >= DigitLimit<base>()) {
417
      // refuse to parse pathological inputs
418
0
      return result;
419
1.46k
    } else if (post_decimal_digits > digits_left) {
420
475
      exponent_adjustment -= digits_left;
421
994
    } else {
422
994
      exponent_adjustment -= post_decimal_digits;
423
994
    }
424
1.46k
  }
425
  // If we've found no mantissa whatsoever, this isn't a number.
426
5.14k
  if (mantissa_begin == begin) {
427
16
    return result;
428
16
  }
429
  // A bare "." doesn't count as a mantissa either.
430
5.12k
  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
431
6
    return result;
432
6
  }
433
434
5.12k
  if (mantissa_is_inexact) {
435
    // We dropped significant digits on the floor.  Handle this appropriately.
436
676
    if (base == 10) {
437
      // If we truncated significant decimal digits, store the full range of the
438
      // mantissa for future big integer math for exact rounding.
439
0
      result.subrange_begin = mantissa_begin;
440
0
      result.subrange_end = begin;
441
676
    } else if (base == 16) {
442
      // If we truncated hex digits, reflect this fact by setting the low
443
      // ("sticky") bit.  This allows for correct rounding in all cases.
444
676
      mantissa |= 1;
445
676
    }
446
676
  }
447
5.12k
  result.mantissa = mantissa;
448
449
5.12k
  const char* const exponent_begin = begin;
450
5.12k
  result.literal_exponent = 0;
451
5.12k
  bool found_exponent = false;
452
5.12k
  if (AllowExponent(format_flags) && begin < end &&
453
5.12k
      IsExponentCharacter<base>(*begin)) {
454
2.50k
    bool negative_exponent = false;
455
2.50k
    ++begin;
456
2.50k
    if (begin < end && *begin == '-') {
457
1.48k
      negative_exponent = true;
458
1.48k
      ++begin;
459
1.48k
    } else if (begin < end && *begin == '+') {
460
266
      ++begin;
461
266
    }
462
2.50k
    const char* const exponent_digits_begin = begin;
463
    // Exponent is always expressed in decimal, even for hexadecimal floats.
464
2.50k
    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
465
2.50k
                               &result.literal_exponent, nullptr);
466
2.50k
    if (begin == exponent_digits_begin) {
467
      // there were no digits where we expected an exponent.  We failed to read
468
      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
469
21
      found_exponent = false;
470
21
      begin = exponent_begin;
471
2.48k
    } else {
472
2.48k
      found_exponent = true;
473
2.48k
      if (negative_exponent) {
474
1.48k
        result.literal_exponent = -result.literal_exponent;
475
1.48k
      }
476
2.48k
    }
477
2.50k
  }
478
479
5.12k
  if (!found_exponent && RequireExponent(format_flags)) {
480
    // Provided flags required an exponent, but none was found.  This results
481
    // in a failure to scan.
482
0
    return result;
483
0
  }
484
485
  // Success!
486
5.12k
  result.type = strings_internal::FloatType::kNumber;
487
5.12k
  if (result.mantissa > 0) {
488
4.41k
    result.exponent = result.literal_exponent +
489
4.41k
                      (DigitMagnitude<base>() * exponent_adjustment);
490
4.41k
  } else {
491
704
    result.exponent = 0;
492
704
  }
493
5.12k
  result.end = begin;
494
5.12k
  return result;
495
5.12k
}
496
497
template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
498
                                    chars_format format_flags);
499
template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
500
                                    chars_format format_flags);
501
502
}  // namespace strings_internal
503
ABSL_NAMESPACE_END
504
}  // namespace absl