1 // Copyright 2017 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 // -----------------------------------------------------------------------------
16 // File: numbers.h
17 // -----------------------------------------------------------------------------
18 //
19 // This package contains functions for converting strings to numbers. For
20 // converting numbers to strings, use `StrCat()` or `StrAppend()` in str_cat.h,
21 // which automatically detect and convert most number values appropriately.
22
23 #ifndef ABSL_STRINGS_NUMBERS_H_
24 #define ABSL_STRINGS_NUMBERS_H_
25
26 #ifdef __SSSE3__
27 #include <tmmintrin.h>
28 #endif
29
30 #ifdef _MSC_VER
31 #include <intrin.h>
32 #endif
33
34 #include <cstddef>
35 #include <cstdlib>
36 #include <cstring>
37 #include <ctime>
38 #include <limits>
39 #include <string>
40 #include <type_traits>
41
42 #include "absl/base/config.h"
43 #include "absl/base/internal/endian.h"
44 #include "absl/base/macros.h"
45 #include "absl/base/nullability.h"
46 #include "absl/base/port.h"
47 #include "absl/numeric/bits.h"
48 #include "absl/numeric/int128.h"
49 #include "absl/strings/string_view.h"
50
51 namespace absl {
52 ABSL_NAMESPACE_BEGIN
53
54 // SimpleAtoi()
55 //
56 // Converts the given string (optionally followed or preceded by ASCII
57 // whitespace) into an integer value, returning `true` if successful. The string
58 // must reflect a base-10 integer whose value falls within the range of the
59 // integer type (optionally preceded by a `+` or `-`). If any errors are
60 // encountered, this function returns `false`, leaving `out` in an unspecified
61 // state.
62 template <typename int_type>
63 ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str,
64 absl::Nonnull<int_type*> out);
65
66 // SimpleAtof()
67 //
68 // Converts the given string (optionally followed or preceded by ASCII
69 // whitespace) into a float, which may be rounded on overflow or underflow,
70 // returning `true` if successful.
71 // See https://en.cppreference.com/w/c/string/byte/strtof for details about the
72 // allowed formats for `str`, except SimpleAtof() is locale-independent and will
73 // always use the "C" locale. If any errors are encountered, this function
74 // returns `false`, leaving `out` in an unspecified state.
75 ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str,
76 absl::Nonnull<float*> out);
77
78 // SimpleAtod()
79 //
80 // Converts the given string (optionally followed or preceded by ASCII
81 // whitespace) into a double, which may be rounded on overflow or underflow,
82 // returning `true` if successful.
83 // See https://en.cppreference.com/w/c/string/byte/strtof for details about the
84 // allowed formats for `str`, except SimpleAtod is locale-independent and will
85 // always use the "C" locale. If any errors are encountered, this function
86 // returns `false`, leaving `out` in an unspecified state.
87 ABSL_MUST_USE_RESULT bool SimpleAtod(absl::string_view str,
88 absl::Nonnull<double*> out);
89
90 // SimpleAtob()
91 //
92 // Converts the given string into a boolean, returning `true` if successful.
93 // The following case-insensitive strings are interpreted as boolean `true`:
94 // "true", "t", "yes", "y", "1". The following case-insensitive strings
95 // are interpreted as boolean `false`: "false", "f", "no", "n", "0". If any
96 // errors are encountered, this function returns `false`, leaving `out` in an
97 // unspecified state.
98 ABSL_MUST_USE_RESULT bool SimpleAtob(absl::string_view str,
99 absl::Nonnull<bool*> out);
100
101 // SimpleHexAtoi()
102 //
103 // Converts a hexadecimal string (optionally followed or preceded by ASCII
104 // whitespace) to an integer, returning `true` if successful. Only valid base-16
105 // hexadecimal integers whose value falls within the range of the integer type
106 // (optionally preceded by a `+` or `-`) can be converted. A valid hexadecimal
107 // value may include both upper and lowercase character symbols, and may
108 // optionally include a leading "0x" (or "0X") number prefix, which is ignored
109 // by this function. If any errors are encountered, this function returns
110 // `false`, leaving `out` in an unspecified state.
111 template <typename int_type>
112 ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str,
113 absl::Nonnull<int_type*> out);
114
115 // Overloads of SimpleHexAtoi() for 128 bit integers.
116 ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(
117 absl::string_view str, absl::Nonnull<absl::int128*> out);
118 ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(
119 absl::string_view str, absl::Nonnull<absl::uint128*> out);
120
121 ABSL_NAMESPACE_END
122 } // namespace absl
123
124 // End of public API. Implementation details follow.
125
126 namespace absl {
127 ABSL_NAMESPACE_BEGIN
128 namespace numbers_internal {
129
130 // Digit conversion.
131 ABSL_DLL extern const char kHexChar[17]; // 0123456789abcdef
132 ABSL_DLL extern const char
133 kHexTable[513]; // 000102030405060708090a0b0c0d0e0f1011...
134
135 // Writes a two-character representation of 'i' to 'buf'. 'i' must be in the
136 // range 0 <= i < 100, and buf must have space for two characters. Example:
137 // char buf[2];
138 // PutTwoDigits(42, buf);
139 // // buf[0] == '4'
140 // // buf[1] == '2'
141 void PutTwoDigits(uint32_t i, absl::Nonnull<char*> buf);
142
143 // safe_strto?() functions for implementing SimpleAtoi()
144
145 bool safe_strto32_base(absl::string_view text, absl::Nonnull<int32_t*> value,
146 int base);
147 bool safe_strto64_base(absl::string_view text, absl::Nonnull<int64_t*> value,
148 int base);
149 bool safe_strto128_base(absl::string_view text,
150 absl::Nonnull<absl::int128*> value, int base);
151 bool safe_strtou32_base(absl::string_view text, absl::Nonnull<uint32_t*> value,
152 int base);
153 bool safe_strtou64_base(absl::string_view text, absl::Nonnull<uint64_t*> value,
154 int base);
155 bool safe_strtou128_base(absl::string_view text,
156 absl::Nonnull<absl::uint128*> value, int base);
157
158 static const int kFastToBufferSize = 32;
159 static const int kSixDigitsToBufferSize = 16;
160
161 // Helper function for fast formatting of floating-point values.
162 // The result is the same as printf's "%g", a.k.a. "%.6g"; that is, six
163 // significant digits are returned, trailing zeros are removed, and numbers
164 // outside the range 0.0001-999999 are output using scientific notation
165 // (1.23456e+06). This routine is heavily optimized.
166 // Required buffer size is `kSixDigitsToBufferSize`.
167 size_t SixDigitsToBuffer(double d, absl::Nonnull<char*> buffer);
168
169 // WARNING: These functions may write more characters than necessary, because
170 // they are intended for speed. All functions take an output buffer
171 // as an argument and return a pointer to the last byte they wrote, which is the
172 // terminating '\0'. At most `kFastToBufferSize` bytes are written.
173 absl::Nonnull<char*> FastIntToBuffer(int32_t i, absl::Nonnull<char*> buffer)
174 ABSL_INTERNAL_NEED_MIN_SIZE(buffer, kFastToBufferSize);
175 absl::Nonnull<char*> FastIntToBuffer(uint32_t n, absl::Nonnull<char*> out_str)
176 ABSL_INTERNAL_NEED_MIN_SIZE(out_str, kFastToBufferSize);
177 absl::Nonnull<char*> FastIntToBuffer(int64_t i, absl::Nonnull<char*> buffer)
178 ABSL_INTERNAL_NEED_MIN_SIZE(buffer, kFastToBufferSize);
179 absl::Nonnull<char*> FastIntToBuffer(uint64_t i, absl::Nonnull<char*> buffer)
180 ABSL_INTERNAL_NEED_MIN_SIZE(buffer, kFastToBufferSize);
181
182 // For enums and integer types that are not an exact match for the types above,
183 // use templates to call the appropriate one of the four overloads above.
184 template <typename int_type>
FastIntToBuffer(int_type i,absl::Nonnull<char * > buffer)185 absl::Nonnull<char*> FastIntToBuffer(int_type i, absl::Nonnull<char*> buffer)
186 ABSL_INTERNAL_NEED_MIN_SIZE(buffer, kFastToBufferSize) {
187 static_assert(sizeof(i) <= 64 / 8,
188 "FastIntToBuffer works only with 64-bit-or-less integers.");
189 // TODO(jorg): This signed-ness check is used because it works correctly
190 // with enums, and it also serves to check that int_type is not a pointer.
191 // If one day something like std::is_signed<enum E> works, switch to it.
192 // These conditions are constexpr bools to suppress MSVC warning C4127.
193 constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
194 constexpr bool kUse64Bit = sizeof(i) > 32 / 8;
195 if (kIsSigned) {
196 if (kUse64Bit) {
197 return FastIntToBuffer(static_cast<int64_t>(i), buffer);
198 } else {
199 return FastIntToBuffer(static_cast<int32_t>(i), buffer);
200 }
201 } else {
202 if (kUse64Bit) {
203 return FastIntToBuffer(static_cast<uint64_t>(i), buffer);
204 } else {
205 return FastIntToBuffer(static_cast<uint32_t>(i), buffer);
206 }
207 }
208 }
209
210 // Implementation of SimpleAtoi, generalized to support arbitrary base (used
211 // with base different from 10 elsewhere in Abseil implementation).
212 template <typename int_type>
safe_strtoi_base(absl::string_view s,absl::Nonnull<int_type * > out,int base)213 ABSL_MUST_USE_RESULT bool safe_strtoi_base(absl::string_view s,
214 absl::Nonnull<int_type*> out,
215 int base) {
216 static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
217 "SimpleAtoi works only with 32-bit or 64-bit integers.");
218 static_assert(!std::is_floating_point<int_type>::value,
219 "Use SimpleAtof or SimpleAtod instead.");
220 bool parsed;
221 // TODO(jorg): This signed-ness check is used because it works correctly
222 // with enums, and it also serves to check that int_type is not a pointer.
223 // If one day something like std::is_signed<enum E> works, switch to it.
224 // These conditions are constexpr bools to suppress MSVC warning C4127.
225 constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
226 constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
227 if (kIsSigned) {
228 if (kUse64Bit) {
229 int64_t val;
230 parsed = numbers_internal::safe_strto64_base(s, &val, base);
231 *out = static_cast<int_type>(val);
232 } else {
233 int32_t val;
234 parsed = numbers_internal::safe_strto32_base(s, &val, base);
235 *out = static_cast<int_type>(val);
236 }
237 } else {
238 if (kUse64Bit) {
239 uint64_t val;
240 parsed = numbers_internal::safe_strtou64_base(s, &val, base);
241 *out = static_cast<int_type>(val);
242 } else {
243 uint32_t val;
244 parsed = numbers_internal::safe_strtou32_base(s, &val, base);
245 *out = static_cast<int_type>(val);
246 }
247 }
248 return parsed;
249 }
250
251 // FastHexToBufferZeroPad16()
252 //
253 // Outputs `val` into `out` as if by `snprintf(out, 17, "%016x", val)` but
254 // without the terminating null character. Thus `out` must be of length >= 16.
255 // Returns the number of non-pad digits of the output (it can never be zero
256 // since 0 has one digit).
FastHexToBufferZeroPad16(uint64_t val,absl::Nonnull<char * > out)257 inline size_t FastHexToBufferZeroPad16(uint64_t val, absl::Nonnull<char*> out) {
258 #ifdef ABSL_INTERNAL_HAVE_SSSE3
259 uint64_t be = absl::big_endian::FromHost64(val);
260 const auto kNibbleMask = _mm_set1_epi8(0xf);
261 const auto kHexDigits = _mm_setr_epi8('0', '1', '2', '3', '4', '5', '6', '7',
262 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
263 auto v = _mm_loadl_epi64(reinterpret_cast<__m128i*>(&be)); // load lo dword
264 auto v4 = _mm_srli_epi64(v, 4); // shift 4 right
265 auto il = _mm_unpacklo_epi8(v4, v); // interleave bytes
266 auto m = _mm_and_si128(il, kNibbleMask); // mask out nibbles
267 auto hexchars = _mm_shuffle_epi8(kHexDigits, m); // hex chars
268 _mm_storeu_si128(reinterpret_cast<__m128i*>(out), hexchars);
269 #else
270 for (int i = 0; i < 8; ++i) {
271 auto byte = (val >> (56 - 8 * i)) & 0xFF;
272 auto* hex = &absl::numbers_internal::kHexTable[byte * 2];
273 std::memcpy(out + 2 * i, hex, 2);
274 }
275 #endif
276 // | 0x1 so that even 0 has 1 digit.
277 return 16 - static_cast<size_t>(countl_zero(val | 0x1) / 4);
278 }
279
280 } // namespace numbers_internal
281
282 template <typename int_type>
SimpleAtoi(absl::string_view str,absl::Nonnull<int_type * > out)283 ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str,
284 absl::Nonnull<int_type*> out) {
285 return numbers_internal::safe_strtoi_base(str, out, 10);
286 }
287
SimpleAtoi(absl::string_view str,absl::Nonnull<absl::int128 * > out)288 ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
289 absl::Nonnull<absl::int128*> out) {
290 return numbers_internal::safe_strto128_base(str, out, 10);
291 }
292
SimpleAtoi(absl::string_view str,absl::Nonnull<absl::uint128 * > out)293 ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
294 absl::Nonnull<absl::uint128*> out) {
295 return numbers_internal::safe_strtou128_base(str, out, 10);
296 }
297
298 template <typename int_type>
SimpleHexAtoi(absl::string_view str,absl::Nonnull<int_type * > out)299 ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str,
300 absl::Nonnull<int_type*> out) {
301 return numbers_internal::safe_strtoi_base(str, out, 16);
302 }
303
SimpleHexAtoi(absl::string_view str,absl::Nonnull<absl::int128 * > out)304 ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(
305 absl::string_view str, absl::Nonnull<absl::int128*> out) {
306 return numbers_internal::safe_strto128_base(str, out, 16);
307 }
308
SimpleHexAtoi(absl::string_view str,absl::Nonnull<absl::uint128 * > out)309 ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(
310 absl::string_view str, absl::Nonnull<absl::uint128*> out) {
311 return numbers_internal::safe_strtou128_base(str, out, 16);
312 }
313
314 ABSL_NAMESPACE_END
315 } // namespace absl
316
317 #endif // ABSL_STRINGS_NUMBERS_H_
318