Restoring authorship annotation for <anastasy888@yandex-team.ru>. Commit 1 of 2.

1 files changed, 237 insertions, 237 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/strings/numbers.h b/contrib/restricted/abseil-cpp/absl/strings/numbers.h
index 899e623c8c..3e309f6542 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/numbers.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/numbers.h
@@ -1,105 +1,105 @@
-// Copyright 2017 The Abseil 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.
-//
-// -----------------------------------------------------------------------------
-// File: numbers.h
-// -----------------------------------------------------------------------------
-//
-// This package contains functions for converting strings to numbers. For
-// converting numbers to strings, use `StrCat()` or `StrAppend()` in str_cat.h,
-// which automatically detect and convert most number values appropriately.
-
-#ifndef ABSL_STRINGS_NUMBERS_H_
-#define ABSL_STRINGS_NUMBERS_H_
-
-#ifdef __SSE4_2__
+// Copyright 2017 The Abseil 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. 
+// 
+// ----------------------------------------------------------------------------- 
+// File: numbers.h 
+// ----------------------------------------------------------------------------- 
+// 
+// This package contains functions for converting strings to numbers. For 
+// converting numbers to strings, use `StrCat()` or `StrAppend()` in str_cat.h, 
+// which automatically detect and convert most number values appropriately. 
+ 
+#ifndef ABSL_STRINGS_NUMBERS_H_ 
+#define ABSL_STRINGS_NUMBERS_H_ 
+ 
+#ifdef __SSE4_2__ 
 #ifdef _MSC_VER
 #include <intrin.h>
 #else
-#include <x86intrin.h>
+#include <x86intrin.h> 
+#endif 
 #endif
-#endif
-
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
-#include <limits>
-#include <string>
-#include <type_traits>
-
+ 
+#include <cstddef> 
+#include <cstdlib> 
+#include <cstring> 
+#include <ctime> 
+#include <limits> 
+#include <string> 
+#include <type_traits> 
+ 
 #include "absl/base/config.h"
-#ifdef __SSE4_2__
-// TODO(jorg): Remove this when we figure out the right way
-// to swap bytes on SSE 4.2 that works with the compilers
-// we claim to support.  Also, add tests for the compiler
-// that doesn't support the Intel _bswap64 intrinsic but
-// does support all the SSE 4.2 intrinsics
-#include "absl/base/internal/endian.h"
-#endif
-#include "absl/base/macros.h"
-#include "absl/base/port.h"
+#ifdef __SSE4_2__ 
+// TODO(jorg): Remove this when we figure out the right way 
+// to swap bytes on SSE 4.2 that works with the compilers 
+// we claim to support.  Also, add tests for the compiler 
+// that doesn't support the Intel _bswap64 intrinsic but 
+// does support all the SSE 4.2 intrinsics 
+#include "absl/base/internal/endian.h" 
+#endif 
+#include "absl/base/macros.h" 
+#include "absl/base/port.h" 
 #include "absl/numeric/bits.h"
-#include "absl/numeric/int128.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
+#include "absl/numeric/int128.h" 
+#include "absl/strings/string_view.h" 
+ 
+namespace absl { 
 ABSL_NAMESPACE_BEGIN
-
-// SimpleAtoi()
-//
+ 
+// SimpleAtoi() 
+// 
 // Converts the given string (optionally followed or preceded by ASCII
 // whitespace) into an integer value, returning `true` if successful. The string
 // must reflect a base-10 integer whose value falls within the range of the
 // integer type (optionally preceded by a `+` or `-`). If any errors are
 // encountered, this function returns `false`, leaving `out` in an unspecified
 // state.
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out);
-
-// SimpleAtof()
-//
-// Converts the given string (optionally followed or preceded by ASCII
+template <typename int_type> 
+ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out); 
+ 
+// SimpleAtof() 
+// 
+// Converts the given string (optionally followed or preceded by ASCII 
 // whitespace) into a float, which may be rounded on overflow or underflow,
 // returning `true` if successful.
-// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
-// allowed formats for `str`, except SimpleAtof() is locale-independent and will
-// always use the "C" locale. If any errors are encountered, this function
-// returns `false`, leaving `out` in an unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str, float* out);
-
-// SimpleAtod()
-//
-// Converts the given string (optionally followed or preceded by ASCII
+// See https://en.cppreference.com/w/c/string/byte/strtof for details about the 
+// allowed formats for `str`, except SimpleAtof() is locale-independent and will 
+// always use the "C" locale. If any errors are encountered, this function 
+// returns `false`, leaving `out` in an unspecified state. 
+ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str, float* out); 
+ 
+// SimpleAtod() 
+// 
+// Converts the given string (optionally followed or preceded by ASCII 
 // whitespace) into a double, which may be rounded on overflow or underflow,
 // returning `true` if successful.
-// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
-// allowed formats for `str`, except SimpleAtod is locale-independent and will
-// always use the "C" locale. If any errors are encountered, this function
-// returns `false`, leaving `out` in an unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtod(absl::string_view str, double* out);
-
-// SimpleAtob()
-//
-// Converts the given string into a boolean, returning `true` if successful.
-// The following case-insensitive strings are interpreted as boolean `true`:
-// "true", "t", "yes", "y", "1". The following case-insensitive strings
-// are interpreted as boolean `false`: "false", "f", "no", "n", "0". If any
-// errors are encountered, this function returns `false`, leaving `out` in an
-// unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtob(absl::string_view str, bool* out);
-
+// See https://en.cppreference.com/w/c/string/byte/strtof for details about the 
+// allowed formats for `str`, except SimpleAtod is locale-independent and will 
+// always use the "C" locale. If any errors are encountered, this function 
+// returns `false`, leaving `out` in an unspecified state. 
+ABSL_MUST_USE_RESULT bool SimpleAtod(absl::string_view str, double* out); 
+ 
+// SimpleAtob() 
+// 
+// Converts the given string into a boolean, returning `true` if successful. 
+// The following case-insensitive strings are interpreted as boolean `true`: 
+// "true", "t", "yes", "y", "1". The following case-insensitive strings 
+// are interpreted as boolean `false`: "false", "f", "no", "n", "0". If any 
+// errors are encountered, this function returns `false`, leaving `out` in an 
+// unspecified state. 
+ABSL_MUST_USE_RESULT bool SimpleAtob(absl::string_view str, bool* out); 
+ 
 // SimpleHexAtoi()
 //
 // Converts a hexadecimal string (optionally followed or preceded by ASCII
@@ -120,169 +120,169 @@ ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
                                                absl::uint128* out);
 
 ABSL_NAMESPACE_END
-}  // namespace absl
-
-// End of public API.  Implementation details follow.
-
-namespace absl {
+}  // namespace absl 
+ 
+// End of public API.  Implementation details follow. 
+ 
+namespace absl { 
 ABSL_NAMESPACE_BEGIN
-namespace numbers_internal {
-
-// Digit conversion.
+namespace numbers_internal { 
+ 
+// Digit conversion. 
 ABSL_DLL extern const char kHexChar[17];  // 0123456789abcdef
 ABSL_DLL extern const char
     kHexTable[513];  // 000102030405060708090a0b0c0d0e0f1011...
 ABSL_DLL extern const char
     two_ASCII_digits[100][2];  // 00, 01, 02, 03...
-
-// Writes a two-character representation of 'i' to 'buf'. 'i' must be in the
-// range 0 <= i < 100, and buf must have space for two characters. Example:
-//   char buf[2];
-//   PutTwoDigits(42, buf);
-//   // buf[0] == '4'
-//   // buf[1] == '2'
-inline void PutTwoDigits(size_t i, char* buf) {
-  assert(i < 100);
-  memcpy(buf, two_ASCII_digits[i], 2);
-}
-
-// safe_strto?() functions for implementing SimpleAtoi()
-
-bool safe_strto32_base(absl::string_view text, int32_t* value, int base);
-bool safe_strto64_base(absl::string_view text, int64_t* value, int base);
+ 
+// Writes a two-character representation of 'i' to 'buf'. 'i' must be in the 
+// range 0 <= i < 100, and buf must have space for two characters. Example: 
+//   char buf[2]; 
+//   PutTwoDigits(42, buf); 
+//   // buf[0] == '4' 
+//   // buf[1] == '2' 
+inline void PutTwoDigits(size_t i, char* buf) { 
+  assert(i < 100); 
+  memcpy(buf, two_ASCII_digits[i], 2); 
+} 
+ 
+// safe_strto?() functions for implementing SimpleAtoi() 
+
+bool safe_strto32_base(absl::string_view text, int32_t* value, int base); 
+bool safe_strto64_base(absl::string_view text, int64_t* value, int base); 
 bool safe_strto128_base(absl::string_view text, absl::int128* value,
                          int base);
-bool safe_strtou32_base(absl::string_view text, uint32_t* value, int base);
-bool safe_strtou64_base(absl::string_view text, uint64_t* value, int base);
-bool safe_strtou128_base(absl::string_view text, absl::uint128* value,
-                         int base);
-
-static const int kFastToBufferSize = 32;
-static const int kSixDigitsToBufferSize = 16;
-
-// Helper function for fast formatting of floating-point values.
-// The result is the same as printf's "%g", a.k.a. "%.6g"; that is, six
-// significant digits are returned, trailing zeros are removed, and numbers
-// outside the range 0.0001-999999 are output using scientific notation
-// (1.23456e+06). This routine is heavily optimized.
-// Required buffer size is `kSixDigitsToBufferSize`.
-size_t SixDigitsToBuffer(double d, char* buffer);
-
-// These functions are intended for speed. All functions take an output buffer
-// as an argument and return a pointer to the last byte they wrote, which is the
-// terminating '\0'. At most `kFastToBufferSize` bytes are written.
-char* FastIntToBuffer(int32_t, char*);
-char* FastIntToBuffer(uint32_t, char*);
-char* FastIntToBuffer(int64_t, char*);
-char* FastIntToBuffer(uint64_t, char*);
-
-// For enums and integer types that are not an exact match for the types above,
-// use templates to call the appropriate one of the four overloads above.
-template <typename int_type>
-char* FastIntToBuffer(int_type i, char* buffer) {
-  static_assert(sizeof(i) <= 64 / 8,
-                "FastIntToBuffer works only with 64-bit-or-less integers.");
-  // TODO(jorg): This signed-ness check is used because it works correctly
-  // with enums, and it also serves to check that int_type is not a pointer.
-  // If one day something like std::is_signed<enum E> works, switch to it.
-  if (static_cast<int_type>(1) - 2 < 0) {  // Signed
-    if (sizeof(i) > 32 / 8) {           // 33-bit to 64-bit
-      return FastIntToBuffer(static_cast<int64_t>(i), buffer);
-    } else {  // 32-bit or less
-      return FastIntToBuffer(static_cast<int32_t>(i), buffer);
-    }
-  } else {                     // Unsigned
-    if (sizeof(i) > 32 / 8) {  // 33-bit to 64-bit
-      return FastIntToBuffer(static_cast<uint64_t>(i), buffer);
-    } else {  // 32-bit or less
-      return FastIntToBuffer(static_cast<uint32_t>(i), buffer);
-    }
-  }
-}
-
-// Implementation of SimpleAtoi, generalized to support arbitrary base (used
-// with base different from 10 elsewhere in Abseil implementation).
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool safe_strtoi_base(absl::string_view s, int_type* out,
-                                           int base) {
-  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
-                "SimpleAtoi works only with 32-bit or 64-bit integers.");
-  static_assert(!std::is_floating_point<int_type>::value,
-                "Use SimpleAtof or SimpleAtod instead.");
-  bool parsed;
-  // TODO(jorg): This signed-ness check is used because it works correctly
-  // with enums, and it also serves to check that int_type is not a pointer.
-  // If one day something like std::is_signed<enum E> works, switch to it.
-  if (static_cast<int_type>(1) - 2 < 0) {  // Signed
-    if (sizeof(*out) == 64 / 8) {       // 64-bit
-      int64_t val;
-      parsed = numbers_internal::safe_strto64_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    } else {  // 32-bit
-      int32_t val;
-      parsed = numbers_internal::safe_strto32_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    }
-  } else {                         // Unsigned
-    if (sizeof(*out) == 64 / 8) {  // 64-bit
-      uint64_t val;
-      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    } else {  // 32-bit
-      uint32_t val;
-      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    }
-  }
-  return parsed;
-}
-
-// FastHexToBufferZeroPad16()
-//
-// Outputs `val` into `out` as if by `snprintf(out, 17, "%016x", val)` but
-// without the terminating null character. Thus `out` must be of length >= 16.
-// Returns the number of non-pad digits of the output (it can never be zero
-// since 0 has one digit).
-inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) {
-#ifdef __SSE4_2__
-  uint64_t be = absl::big_endian::FromHost64(val);
-  const auto kNibbleMask = _mm_set1_epi8(0xf);
-  const auto kHexDigits = _mm_setr_epi8('0', '1', '2', '3', '4', '5', '6', '7',
-                                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
-  auto v = _mm_loadl_epi64(reinterpret_cast<__m128i*>(&be));  // load lo dword
-  auto v4 = _mm_srli_epi64(v, 4);                            // shift 4 right
-  auto il = _mm_unpacklo_epi8(v4, v);                        // interleave bytes
-  auto m = _mm_and_si128(il, kNibbleMask);                   // mask out nibbles
-  auto hexchars = _mm_shuffle_epi8(kHexDigits, m);           // hex chars
-  _mm_storeu_si128(reinterpret_cast<__m128i*>(out), hexchars);
-#else
-  for (int i = 0; i < 8; ++i) {
-    auto byte = (val >> (56 - 8 * i)) & 0xFF;
-    auto* hex = &absl::numbers_internal::kHexTable[byte * 2];
-    std::memcpy(out + 2 * i, hex, 2);
-  }
-#endif
-  // | 0x1 so that even 0 has 1 digit.
+bool safe_strtou32_base(absl::string_view text, uint32_t* value, int base); 
+bool safe_strtou64_base(absl::string_view text, uint64_t* value, int base); 
+bool safe_strtou128_base(absl::string_view text, absl::uint128* value, 
+                         int base); 
+ 
+static const int kFastToBufferSize = 32; 
+static const int kSixDigitsToBufferSize = 16; 
+ 
+// Helper function for fast formatting of floating-point values. 
+// The result is the same as printf's "%g", a.k.a. "%.6g"; that is, six 
+// significant digits are returned, trailing zeros are removed, and numbers 
+// outside the range 0.0001-999999 are output using scientific notation 
+// (1.23456e+06). This routine is heavily optimized. 
+// Required buffer size is `kSixDigitsToBufferSize`. 
+size_t SixDigitsToBuffer(double d, char* buffer); 
+ 
+// These functions are intended for speed. All functions take an output buffer 
+// as an argument and return a pointer to the last byte they wrote, which is the 
+// terminating '\0'. At most `kFastToBufferSize` bytes are written. 
+char* FastIntToBuffer(int32_t, char*); 
+char* FastIntToBuffer(uint32_t, char*); 
+char* FastIntToBuffer(int64_t, char*); 
+char* FastIntToBuffer(uint64_t, char*); 
+ 
+// For enums and integer types that are not an exact match for the types above, 
+// use templates to call the appropriate one of the four overloads above. 
+template <typename int_type> 
+char* FastIntToBuffer(int_type i, char* buffer) { 
+  static_assert(sizeof(i) <= 64 / 8, 
+                "FastIntToBuffer works only with 64-bit-or-less integers."); 
+  // TODO(jorg): This signed-ness check is used because it works correctly 
+  // with enums, and it also serves to check that int_type is not a pointer. 
+  // If one day something like std::is_signed<enum E> works, switch to it. 
+  if (static_cast<int_type>(1) - 2 < 0) {  // Signed 
+    if (sizeof(i) > 32 / 8) {           // 33-bit to 64-bit 
+      return FastIntToBuffer(static_cast<int64_t>(i), buffer); 
+    } else {  // 32-bit or less 
+      return FastIntToBuffer(static_cast<int32_t>(i), buffer); 
+    } 
+  } else {                     // Unsigned 
+    if (sizeof(i) > 32 / 8) {  // 33-bit to 64-bit 
+      return FastIntToBuffer(static_cast<uint64_t>(i), buffer); 
+    } else {  // 32-bit or less 
+      return FastIntToBuffer(static_cast<uint32_t>(i), buffer); 
+    } 
+  } 
+} 
+ 
+// Implementation of SimpleAtoi, generalized to support arbitrary base (used 
+// with base different from 10 elsewhere in Abseil implementation). 
+template <typename int_type> 
+ABSL_MUST_USE_RESULT bool safe_strtoi_base(absl::string_view s, int_type* out, 
+                                           int base) { 
+  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8, 
+                "SimpleAtoi works only with 32-bit or 64-bit integers."); 
+  static_assert(!std::is_floating_point<int_type>::value, 
+                "Use SimpleAtof or SimpleAtod instead."); 
+  bool parsed; 
+  // TODO(jorg): This signed-ness check is used because it works correctly 
+  // with enums, and it also serves to check that int_type is not a pointer. 
+  // If one day something like std::is_signed<enum E> works, switch to it. 
+  if (static_cast<int_type>(1) - 2 < 0) {  // Signed 
+    if (sizeof(*out) == 64 / 8) {       // 64-bit 
+      int64_t val; 
+      parsed = numbers_internal::safe_strto64_base(s, &val, base); 
+      *out = static_cast<int_type>(val); 
+    } else {  // 32-bit 
+      int32_t val; 
+      parsed = numbers_internal::safe_strto32_base(s, &val, base); 
+      *out = static_cast<int_type>(val); 
+    } 
+  } else {                         // Unsigned 
+    if (sizeof(*out) == 64 / 8) {  // 64-bit 
+      uint64_t val; 
+      parsed = numbers_internal::safe_strtou64_base(s, &val, base); 
+      *out = static_cast<int_type>(val); 
+    } else {  // 32-bit 
+      uint32_t val; 
+      parsed = numbers_internal::safe_strtou32_base(s, &val, base); 
+      *out = static_cast<int_type>(val); 
+    } 
+  } 
+  return parsed; 
+} 
+ 
+// FastHexToBufferZeroPad16() 
+// 
+// Outputs `val` into `out` as if by `snprintf(out, 17, "%016x", val)` but 
+// without the terminating null character. Thus `out` must be of length >= 16. 
+// Returns the number of non-pad digits of the output (it can never be zero 
+// since 0 has one digit). 
+inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) { 
+#ifdef __SSE4_2__ 
+  uint64_t be = absl::big_endian::FromHost64(val); 
+  const auto kNibbleMask = _mm_set1_epi8(0xf); 
+  const auto kHexDigits = _mm_setr_epi8('0', '1', '2', '3', '4', '5', '6', '7', 
+                                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'); 
+  auto v = _mm_loadl_epi64(reinterpret_cast<__m128i*>(&be));  // load lo dword 
+  auto v4 = _mm_srli_epi64(v, 4);                            // shift 4 right 
+  auto il = _mm_unpacklo_epi8(v4, v);                        // interleave bytes 
+  auto m = _mm_and_si128(il, kNibbleMask);                   // mask out nibbles 
+  auto hexchars = _mm_shuffle_epi8(kHexDigits, m);           // hex chars 
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(out), hexchars); 
+#else 
+  for (int i = 0; i < 8; ++i) { 
+    auto byte = (val >> (56 - 8 * i)) & 0xFF; 
+    auto* hex = &absl::numbers_internal::kHexTable[byte * 2]; 
+    std::memcpy(out + 2 * i, hex, 2); 
+  } 
+#endif 
+  // | 0x1 so that even 0 has 1 digit. 
   return 16 - countl_zero(val | 0x1) / 4;
-}
-
-}  // namespace numbers_internal
-
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out) {
-  return numbers_internal::safe_strtoi_base(str, out, 10);
-}
-
-ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
+} 
+ 
+}  // namespace numbers_internal 
+ 
+template <typename int_type> 
+ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out) { 
+  return numbers_internal::safe_strtoi_base(str, out, 10); 
+} 
+ 
+ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str, 
                                             absl::int128* out) {
   return numbers_internal::safe_strto128_base(str, out, 10);
 }
 
 ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
-                                            absl::uint128* out) {
-  return numbers_internal::safe_strtou128_base(str, out, 10);
-}
-
+                                            absl::uint128* out) { 
+  return numbers_internal::safe_strtou128_base(str, out, 10); 
+} 
+ 
 template <typename int_type>
 ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str, int_type* out) {
   return numbers_internal::safe_strtoi_base(str, out, 16);
@@ -299,6 +299,6 @@ ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
 }
 
 ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_NUMBERS_H_
+}  // namespace absl 
+ 
+#endif  // ABSL_STRINGS_NUMBERS_H_