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#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
16#define ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
17
18#include <cstdint>
19
20#include "absl/strings/charconv.h"
21
22namespace absl {
23namespace strings_internal {
24
25// Enum indicating whether a parsed float is a number or special value.
26enum class FloatType { kNumber, kInfinity, kNan };
27
28// The decomposed parts of a parsed `float` or `double`.
29struct ParsedFloat {
30 // Representation of the parsed mantissa, with the decimal point adjusted to
31 // make it an integer.
32 //
33 // During decimal scanning, this contains 19 significant digits worth of
34 // mantissa value. If digits beyond this point are found, they
35 // are truncated, and if any of these dropped digits are nonzero, then
36 // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin,
37 // subrange_end).
38 //
39 // During hexadecimal scanning, this contains 15 significant hex digits worth
40 // of mantissa value. Digits beyond this point are sticky -- they are
41 // truncated, but if any dropped digits are nonzero, the low bit of mantissa
42 // will be set. (This allows for precise rounding, and avoids the need
43 // to store the full mantissa in [subrange_begin, subrange_end).)
44 uint64_t mantissa = 0;
45
46 // Floating point expontent. This reflects any decimal point adjustments and
47 // any truncated digits from the mantissa. The absolute value of the parsed
48 // number is represented by mantissa * (base ** exponent), where base==10 for
49 // decimal floats, and base==2 for hexadecimal floats.
50 int exponent = 0;
51
52 // The literal exponent value scanned from the input, or 0 if none was
53 // present. This does not reflect any adjustments applied to mantissa.
54 int literal_exponent = 0;
55
56 // The type of number scanned.
57 FloatType type = FloatType::kNumber;
58
59 // When non-null, [subrange_begin, subrange_end) marks a range of characters
60 // that require further processing. The meaning is dependent on float type.
61 // If type == kNumber and this is set, this is a "wide input": the input
62 // mantissa contained more than 19 digits. The range contains the full
63 // mantissa. It plus `literal_exponent` need to be examined to find the best
64 // floating point match.
65 // If type == kNan and this is set, the range marks the contents of a
66 // matched parenthesized character region after the NaN.
67 const char* subrange_begin = nullptr;
68 const char* subrange_end = nullptr;
69
70 // One-past-the-end of the successfully parsed region, or nullptr if no
71 // matching pattern was found.
72 const char* end = nullptr;
73};
74
75// Read the floating point number in the provided range, and populate
76// ParsedFloat accordingly.
77//
78// format_flags is a bitmask value specifying what patterns this API will match.
79// `scientific` and `fixed` are honored per std::from_chars rules
80// ([utility.from.chars], C++17): if exactly one of these bits is set, then an
81// exponent is required, or dislallowed, respectively.
82//
83// Template parameter `base` must be either 10 or 16. For base 16, a "0x" is
84// *not* consumed. The `hex` bit from format_flags is ignored by ParseFloat.
85template <int base>
86ParsedFloat ParseFloat(const char* begin, const char* end,
87 absl::chars_format format_flags);
88
89extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
90 absl::chars_format format_flags);
91extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
92 absl::chars_format format_flags);
93
94} // namespace strings_internal
95} // namespace absl
96#endif // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
97