Coverage Report

Created: 2023-06-07 07:09

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