From 4b551344e6ba3243636d841d5a2d944a20a3a956 Mon Sep 17 00:00:00 2001 From: Thomas Köppe Date: Thu, 4 Aug 2022 06:14:14 -0700 Subject: Revert change "Fix "unsafe narrowing" warnings in absl, 4/n.". The change breaks existing code by changing the return type of absl::bit_width. PiperOrigin-RevId: 465295951 Change-Id: Id4ce7c2ac3699ce22aa2b4851a949f9e0104a3d7 --- absl/strings/ascii.cc | 10 ++-- absl/strings/charconv.cc | 31 ++++------- absl/strings/cord.cc | 7 ++- absl/strings/cord_buffer.h | 8 +-- absl/strings/escaping.cc | 128 ++++++++++++++++++++------------------------ absl/strings/numbers.cc | 65 +++++++++++----------- absl/strings/str_cat.cc | 4 +- absl/strings/string_view.cc | 12 ++--- absl/strings/substitute.cc | 14 +++-- 9 files changed, 123 insertions(+), 156 deletions(-) (limited to 'absl/strings') diff --git a/absl/strings/ascii.cc b/absl/strings/ascii.cc index 868df2d1..93bb03e9 100644 --- a/absl/strings/ascii.cc +++ b/absl/strings/ascii.cc @@ -157,13 +157,13 @@ ABSL_DLL const char kToUpper[256] = { void AsciiStrToLower(std::string* s) { for (auto& ch : *s) { - ch = absl::ascii_tolower(static_cast(ch)); + ch = absl::ascii_tolower(ch); } } void AsciiStrToUpper(std::string* s) { for (auto& ch : *s) { - ch = absl::ascii_toupper(static_cast(ch)); + ch = absl::ascii_toupper(ch); } } @@ -183,17 +183,17 @@ void RemoveExtraAsciiWhitespace(std::string* str) { for (; input_it < input_end; ++input_it) { if (is_ws) { // Consecutive whitespace? Keep only the last. - is_ws = absl::ascii_isspace(static_cast(*input_it)); + is_ws = absl::ascii_isspace(*input_it); if (is_ws) --output_it; } else { - is_ws = absl::ascii_isspace(static_cast(*input_it)); + is_ws = absl::ascii_isspace(*input_it); } *output_it = *input_it; ++output_it; } - str->erase(static_cast(output_it - &(*str)[0])); + str->erase(output_it - &(*str)[0]); } ABSL_NAMESPACE_END diff --git a/absl/strings/charconv.cc b/absl/strings/charconv.cc index 65d1beb1..fefcfc90 100644 --- a/absl/strings/charconv.cc +++ b/absl/strings/charconv.cc @@ -65,8 +65,6 @@ struct FloatTraits; template <> struct FloatTraits { - using mantissa_t = uint64_t; - // The number of mantissa bits in the given float type. This includes the // implied high bit. static constexpr int kTargetMantissaBits = 53; @@ -105,7 +103,7 @@ struct FloatTraits { // a normal value is made, or it must be less narrow than that, in which case // `exponent` must be exactly kMinNormalExponent, and a subnormal value is // made. - static double Make(mantissa_t mantissa, int exponent, bool sign) { + static double Make(uint64_t mantissa, int exponent, bool sign) { #ifndef ABSL_BIT_PACK_FLOATS // Support ldexp no matter which namespace it's in. Some platforms // incorrectly don't put it in namespace std. @@ -118,10 +116,8 @@ struct FloatTraits { if (mantissa > kMantissaMask) { // Normal value. // Adjust by 1023 for the exponent representation bias, and an additional - // 52 due to the implied decimal point in the IEEE mantissa - // representation. - dbl += static_cast(exponent + 1023 + kTargetMantissaBits - 1) - << 52; + // 52 due to the implied decimal point in the IEEE mantissa represenation. + dbl += uint64_t{exponent + 1023u + kTargetMantissaBits - 1} << 52; mantissa &= kMantissaMask; } else { // subnormal value @@ -138,20 +134,16 @@ struct FloatTraits { // members and methods. template <> struct FloatTraits { - using mantissa_t = uint32_t; - static constexpr int kTargetMantissaBits = 24; static constexpr int kMaxExponent = 104; static constexpr int kMinNormalExponent = -149; - static float MakeNan(const char* tagp) { // Support nanf no matter which namespace it's in. Some platforms // incorrectly don't put it in namespace std. using namespace std; // NOLINT return nanf(tagp); } - - static float Make(mantissa_t mantissa, int exponent, bool sign) { + static float Make(uint32_t mantissa, int exponent, bool sign) { #ifndef ABSL_BIT_PACK_FLOATS // Support ldexpf no matter which namespace it's in. Some platforms // incorrectly don't put it in namespace std. @@ -165,8 +157,7 @@ struct FloatTraits { // Normal value. // Adjust by 127 for the exponent representation bias, and an additional // 23 due to the implied decimal point in the IEEE mantissa represenation. - flt += static_cast(exponent + 127 + kTargetMantissaBits - 1) - << 23; + flt += uint32_t{exponent + 127u + kTargetMantissaBits - 1} << 23; mantissa &= kMantissaMask; } else { // subnormal value @@ -251,9 +242,9 @@ struct CalculatedFloat { // Returns the bit width of the given uint128. (Equivalently, returns 128 // minus the number of leading zero bits.) -int BitWidth(uint128 value) { +unsigned BitWidth(uint128 value) { if (Uint128High64(value) == 0) { - return bit_width(Uint128Low64(value)); + return static_cast(bit_width(Uint128Low64(value))); } return 128 - countl_zero(Uint128High64(value)); } @@ -346,10 +337,8 @@ void EncodeResult(const CalculatedFloat& calculated, bool negative, *value = negative ? -0.0 : 0.0; return; } - *value = FloatTraits::Make( - static_cast::mantissa_t>( - calculated.mantissa), - calculated.exponent, negative); + *value = FloatTraits::Make(calculated.mantissa, + calculated.exponent, negative); } // Returns the given uint128 shifted to the right by `shift` bits, and rounds @@ -530,7 +519,7 @@ CalculatedFloat CalculateFromParsedHexadecimal( const strings_internal::ParsedFloat& parsed_hex) { uint64_t mantissa = parsed_hex.mantissa; int exponent = parsed_hex.exponent; - int mantissa_width = bit_width(mantissa); + auto mantissa_width = static_cast(bit_width(mantissa)); const int shift = NormalizedShiftSize(mantissa_width, exponent); bool result_exact; exponent += shift; diff --git a/absl/strings/cord.cc b/absl/strings/cord.cc index 523379e4..b34c03a2 100644 --- a/absl/strings/cord.cc +++ b/absl/strings/cord.cc @@ -20,7 +20,6 @@ #include #include #include -#include #include #include #include @@ -185,7 +184,7 @@ inline void Cord::InlineRep::reduce_size(size_t n) { assert(tag >= n); tag -= n; memset(data_.as_chars() + tag, 0, n); - set_inline_size(tag); + set_inline_size(static_cast(tag)); } inline void Cord::InlineRep::remove_prefix(size_t n) { @@ -1099,7 +1098,7 @@ Cord Cord::ChunkIterator::AdvanceAndReadBytes(size_t n) { : current_leaf_; const char* data = payload->IsExternal() ? payload->external()->base : payload->flat()->Data(); - const size_t offset = static_cast(current_chunk_.data() - data); + const size_t offset = current_chunk_.data() - data; auto* tree = CordRepSubstring::Substring(payload, offset, n); subcord.contents_.EmplaceTree(VerifyTree(tree), method); @@ -1309,7 +1308,7 @@ static bool VerifyNode(CordRep* root, CordRep* start_node, std::ostream& operator<<(std::ostream& out, const Cord& cord) { for (absl::string_view chunk : cord.Chunks()) { - out.write(chunk.data(), static_cast(chunk.size())); + out.write(chunk.data(), chunk.size()); } return out; } diff --git a/absl/strings/cord_buffer.h b/absl/strings/cord_buffer.h index 15494b31..09a74ad5 100644 --- a/absl/strings/cord_buffer.h +++ b/absl/strings/cord_buffer.h @@ -411,12 +411,8 @@ class CordBuffer { // Power2 functions static bool IsPow2(size_t size) { return absl::has_single_bit(size); } - static size_t Log2Floor(size_t size) { - return static_cast(absl::bit_width(size) - 1); - } - static size_t Log2Ceil(size_t size) { - return static_cast(absl::bit_width(size - 1)); - } + static size_t Log2Floor(size_t size) { return absl::bit_width(size) - 1; } + static size_t Log2Ceil(size_t size) { return absl::bit_width(size - 1); } // Implementation of `CreateWithCustomLimit()`. // This implementation allows for future memory allocation hints to diff --git a/absl/strings/escaping.cc b/absl/strings/escaping.cc index 7d97944e..4dc69702 100644 --- a/absl/strings/escaping.cc +++ b/absl/strings/escaping.cc @@ -42,11 +42,11 @@ constexpr bool kUnescapeNulls = false; inline bool is_octal_digit(char c) { return ('0' <= c) && (c <= '7'); } -inline unsigned int hex_digit_to_int(char c) { +inline int hex_digit_to_int(char c) { static_assert('0' == 0x30 && 'A' == 0x41 && 'a' == 0x61, "Character set must be ASCII."); - assert(absl::ascii_isxdigit(static_cast(c))); - unsigned int x = static_cast(c); + assert(absl::ascii_isxdigit(c)); + int x = static_cast(c); if (x > '9') { x += 9; } @@ -121,29 +121,27 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped, case '7': { // octal digit: 1 to 3 digits const char* octal_start = p; - unsigned int ch = static_cast(*p - '0'); // digit 1 + unsigned int ch = *p - '0'; + if (p < last_byte && is_octal_digit(p[1])) ch = ch * 8 + *++p - '0'; if (p < last_byte && is_octal_digit(p[1])) - ch = ch * 8 + static_cast(*++p - '0'); // digit 2 - if (p < last_byte && is_octal_digit(p[1])) - ch = ch * 8 + static_cast(*++p - '0'); // digit 3 + ch = ch * 8 + *++p - '0'; // now points at last digit if (ch > 0xff) { if (error) { *error = "Value of \\" + - std::string(octal_start, - static_cast(p + 1 - octal_start)) + + std::string(octal_start, p + 1 - octal_start) + " exceeds 0xff"; } return false; } if ((ch == 0) && leave_nulls_escaped) { // Copy the escape sequence for the null character - const size_t octal_size = static_cast(p + 1 - octal_start); + const ptrdiff_t octal_size = p + 1 - octal_start; *d++ = '\\'; memmove(d, octal_start, octal_size); d += octal_size; break; } - *d++ = static_cast(ch); + *d++ = ch; break; } case 'x': @@ -151,34 +149,32 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped, if (p >= last_byte) { if (error) *error = "String cannot end with \\x"; return false; - } else if (!absl::ascii_isxdigit(static_cast(p[1]))) { + } else if (!absl::ascii_isxdigit(p[1])) { if (error) *error = "\\x cannot be followed by a non-hex digit"; return false; } unsigned int ch = 0; const char* hex_start = p; - while (p < last_byte && - absl::ascii_isxdigit(static_cast(p[1]))) + while (p < last_byte && absl::ascii_isxdigit(p[1])) // Arbitrarily many hex digits ch = (ch << 4) + hex_digit_to_int(*++p); if (ch > 0xFF) { if (error) { *error = "Value of \\" + - std::string(hex_start, - static_cast(p + 1 - hex_start)) + + std::string(hex_start, p + 1 - hex_start) + " exceeds 0xff"; } return false; } if ((ch == 0) && leave_nulls_escaped) { // Copy the escape sequence for the null character - const size_t hex_size = static_cast(p + 1 - hex_start); + const ptrdiff_t hex_size = p + 1 - hex_start; *d++ = '\\'; memmove(d, hex_start, hex_size); d += hex_size; break; } - *d++ = static_cast(ch); + *d++ = ch; break; } case 'u': { @@ -188,20 +184,18 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped, if (p + 4 >= end) { if (error) { *error = "\\u must be followed by 4 hex digits: \\" + - std::string(hex_start, - static_cast(p + 1 - hex_start)); + std::string(hex_start, p + 1 - hex_start); } return false; } for (int i = 0; i < 4; ++i) { // Look one char ahead. - if (absl::ascii_isxdigit(static_cast(p[1]))) { + if (absl::ascii_isxdigit(p[1])) { rune = (rune << 4) + hex_digit_to_int(*++p); // Advance p. } else { if (error) { *error = "\\u must be followed by 4 hex digits: \\" + - std::string(hex_start, - static_cast(p + 1 - hex_start)); + std::string(hex_start, p + 1 - hex_start); } return false; } @@ -226,22 +220,20 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped, if (p + 8 >= end) { if (error) { *error = "\\U must be followed by 8 hex digits: \\" + - std::string(hex_start, - static_cast(p + 1 - hex_start)); + std::string(hex_start, p + 1 - hex_start); } return false; } for (int i = 0; i < 8; ++i) { // Look one char ahead. - if (absl::ascii_isxdigit(static_cast(p[1]))) { + if (absl::ascii_isxdigit(p[1])) { // Don't change rune until we're sure this // is within the Unicode limit, but do advance p. uint32_t newrune = (rune << 4) + hex_digit_to_int(*++p); if (newrune > 0x10FFFF) { if (error) { *error = "Value of \\" + - std::string(hex_start, - static_cast(p + 1 - hex_start)) + + std::string(hex_start, p + 1 - hex_start) + " exceeds Unicode limit (0x10FFFF)"; } return false; @@ -251,8 +243,7 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped, } else { if (error) { *error = "\\U must be followed by 8 hex digits: \\" + - std::string(hex_start, - static_cast(p + 1 - hex_start)); + std::string(hex_start, p + 1 - hex_start); } return false; } @@ -300,7 +291,7 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped, error)) { return false; } - dest->erase(static_cast(dest_size)); + dest->erase(dest_size); return true; } @@ -320,7 +311,7 @@ std::string CEscapeInternal(absl::string_view src, bool use_hex, std::string dest; bool last_hex_escape = false; // true if last output char was \xNN. - for (char c : src) { + for (unsigned char c : src) { bool is_hex_escape = false; switch (c) { case '\n': dest.append("\\" "n"); break; @@ -329,30 +320,28 @@ std::string CEscapeInternal(absl::string_view src, bool use_hex, case '\"': dest.append("\\" "\""); break; case '\'': dest.append("\\" "'"); break; case '\\': dest.append("\\" "\\"); break; - default: { + default: // Note that if we emit \xNN and the src character after that is a hex // digit then that digit must be escaped too to prevent it being // interpreted as part of the character code by C. - const unsigned char uc = static_cast(c); - if ((!utf8_safe || uc < 0x80) && - (!absl::ascii_isprint(uc) || - (last_hex_escape && absl::ascii_isxdigit(uc)))) { + if ((!utf8_safe || c < 0x80) && + (!absl::ascii_isprint(c) || + (last_hex_escape && absl::ascii_isxdigit(c)))) { if (use_hex) { dest.append("\\" "x"); - dest.push_back(numbers_internal::kHexChar[uc / 16]); - dest.push_back(numbers_internal::kHexChar[uc % 16]); + dest.push_back(numbers_internal::kHexChar[c / 16]); + dest.push_back(numbers_internal::kHexChar[c % 16]); is_hex_escape = true; } else { dest.append("\\"); - dest.push_back(numbers_internal::kHexChar[uc / 64]); - dest.push_back(numbers_internal::kHexChar[(uc % 64) / 8]); - dest.push_back(numbers_internal::kHexChar[uc % 8]); + dest.push_back(numbers_internal::kHexChar[c / 64]); + dest.push_back(numbers_internal::kHexChar[(c % 64) / 8]); + dest.push_back(numbers_internal::kHexChar[c % 8]); } } else { dest.push_back(c); break; } - } } last_hex_escape = is_hex_escape; } @@ -361,7 +350,7 @@ std::string CEscapeInternal(absl::string_view src, bool use_hex, } /* clang-format off */ -constexpr unsigned char c_escaped_len[256] = { +constexpr char c_escaped_len[256] = { 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 4, 4, 2, 4, 4, // \t, \n, \r 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // ", ' @@ -386,8 +375,7 @@ constexpr unsigned char c_escaped_len[256] = { // that UTF-8 bytes are not handled specially. inline size_t CEscapedLength(absl::string_view src) { size_t escaped_len = 0; - for (char c : src) - escaped_len += c_escaped_len[static_cast(c)]; + for (unsigned char c : src) escaped_len += c_escaped_len[c]; return escaped_len; } @@ -403,8 +391,8 @@ void CEscapeAndAppendInternal(absl::string_view src, std::string* dest) { cur_dest_len + escaped_len); char* append_ptr = &(*dest)[cur_dest_len]; - for (char c : src) { - size_t char_len = c_escaped_len[static_cast(c)]; + for (unsigned char c : src) { + int char_len = c_escaped_len[c]; if (char_len == 1) { *append_ptr++ = c; } else if (char_len == 2) { @@ -436,9 +424,9 @@ void CEscapeAndAppendInternal(absl::string_view src, std::string* dest) { } } else { *append_ptr++ = '\\'; - *append_ptr++ = '0' + static_cast(c) / 64; - *append_ptr++ = '0' + (static_cast(c) % 64) / 8; - *append_ptr++ = '0' + static_cast(c) % 8; + *append_ptr++ = '0' + c / 64; + *append_ptr++ = '0' + (c % 64) / 8; + *append_ptr++ = '0' + c % 8; } } } @@ -452,7 +440,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, size_t destidx = 0; int decode = 0; int state = 0; - unsigned char ch = 0; + unsigned int ch = 0; unsigned int temp = 0; // If "char" is signed by default, using *src as an array index results in @@ -512,13 +500,13 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, // how to handle those cases. GET_INPUT(first, 4); - temp = static_cast(decode); + temp = decode; GET_INPUT(second, 3); - temp = (temp << 6) | static_cast(decode); + temp = (temp << 6) | decode; GET_INPUT(third, 2); - temp = (temp << 6) | static_cast(decode); + temp = (temp << 6) | decode; GET_INPUT(fourth, 1); - temp = (temp << 6) | static_cast(decode); + temp = (temp << 6) | decode; } else { // We really did have four good data bytes, so advance four // characters in the string. @@ -530,11 +518,11 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, // temp has 24 bits of input, so write that out as three bytes. if (destidx + 3 > szdest) return false; - dest[destidx + 2] = static_cast(temp); + dest[destidx + 2] = temp; temp >>= 8; - dest[destidx + 1] = static_cast(temp); + dest[destidx + 1] = temp; temp >>= 8; - dest[destidx] = static_cast(temp); + dest[destidx] = temp; destidx += 3; } } else { @@ -595,18 +583,18 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, } // Each input character gives us six bits of output. - temp = (temp << 6) | static_cast(decode); + temp = (temp << 6) | decode; ++state; if (state == 4) { // If we've accumulated 24 bits of output, write that out as // three bytes. if (dest) { if (destidx + 3 > szdest) return false; - dest[destidx + 2] = static_cast(temp); + dest[destidx + 2] = temp; temp >>= 8; - dest[destidx + 1] = static_cast(temp); + dest[destidx + 1] = temp; temp >>= 8; - dest[destidx] = static_cast(temp); + dest[destidx] = temp; } destidx += 3; state = 0; @@ -631,7 +619,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, if (dest) { if (destidx + 1 > szdest) return false; temp >>= 4; - dest[destidx] = static_cast(temp); + dest[destidx] = temp; } ++destidx; expected_equals = 2; @@ -642,9 +630,9 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest, if (dest) { if (destidx + 2 > szdest) return false; temp >>= 2; - dest[destidx + 1] = static_cast(temp); + dest[destidx + 1] = temp; temp >>= 8; - dest[destidx] = static_cast(temp); + dest[destidx] = temp; } destidx += 2; expected_equals = 1; @@ -834,9 +822,9 @@ constexpr char kHexValueLenient[256] = { // or a string. This works because we use the [] operator to access // individual characters at a time. template -void HexStringToBytesInternal(const char* from, T to, size_t num) { - for (size_t i = 0; i < num; i++) { - to[i] = static_cast(kHexValueLenient[from[i * 2] & 0xFF] << 4) + +void HexStringToBytesInternal(const char* from, T to, ptrdiff_t num) { + for (int i = 0; i < num; i++) { + to[i] = (kHexValueLenient[from[i * 2] & 0xFF] << 4) + (kHexValueLenient[from[i * 2 + 1] & 0xFF]); } } @@ -844,7 +832,7 @@ void HexStringToBytesInternal(const char* from, T to, size_t num) { // This is a templated function so that T can be either a char* or a // std::string. template -void BytesToHexStringInternal(const unsigned char* src, T dest, size_t num) { +void BytesToHexStringInternal(const unsigned char* src, T dest, ptrdiff_t num) { auto dest_ptr = &dest[0]; for (auto src_ptr = src; src_ptr != (src + num); ++src_ptr, dest_ptr += 2) { const char* hex_p = &numbers_internal::kHexTable[*src_ptr * 2]; diff --git a/absl/strings/numbers.cc b/absl/strings/numbers.cc index 2987158e..e798fc69 100644 --- a/absl/strings/numbers.cc +++ b/absl/strings/numbers.cc @@ -190,32 +190,32 @@ char* numbers_internal::FastIntToBuffer(uint32_t i, char* buffer) { if (i >= 1000) goto lt10_000; digits = i / 100; i -= digits * 100; - *buffer++ = '0' + static_cast(digits); + *buffer++ = '0' + digits; goto lt100; } if (i < 1000000) { // 1,000,000 if (i >= 100000) goto lt1_000_000; digits = i / 10000; // 10,000 i -= digits * 10000; - *buffer++ = '0' + static_cast(digits); + *buffer++ = '0' + digits; goto lt10_000; } if (i < 100000000) { // 100,000,000 if (i >= 10000000) goto lt100_000_000; digits = i / 1000000; // 1,000,000 i -= digits * 1000000; - *buffer++ = '0' + static_cast(digits); + *buffer++ = '0' + digits; goto lt1_000_000; } // we already know that i < 1,000,000,000 digits = i / 100000000; // 100,000,000 i -= digits * 100000000; - *buffer++ = '0' + static_cast(digits); + *buffer++ = '0' + digits; goto lt100_000_000; } char* numbers_internal::FastIntToBuffer(int32_t i, char* buffer) { - uint32_t u = static_cast(i); + uint32_t u = i; if (i < 0) { *buffer++ = '-'; // We need to do the negation in modular (i.e., "unsigned") @@ -268,7 +268,7 @@ char* numbers_internal::FastIntToBuffer(uint64_t i, char* buffer) { } char* numbers_internal::FastIntToBuffer(int64_t i, char* buffer) { - uint64_t u = static_cast(i); + uint64_t u = i; if (i < 0) { *buffer++ = '-'; u = 0 - u; @@ -329,7 +329,7 @@ static std::pair PowFive(uint64_t num, int expfive) { result = Mul32(result, 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5); expfive -= 13; } - constexpr uint32_t powers_of_five[13] = { + constexpr int powers_of_five[13] = { 1, 5, 5 * 5, @@ -404,14 +404,14 @@ static ExpDigits SplitToSix(const double value) { // we multiply it by 65536 and see if the fractional part is close to 32768. // (The number doesn't have to be a power of two,but powers of two are faster) uint64_t d64k = d * 65536; - uint32_t dddddd; // A 6-digit decimal integer. + int dddddd; // A 6-digit decimal integer. if ((d64k % 65536) == 32767 || (d64k % 65536) == 32768) { // OK, it's fairly likely that precision was lost above, which is // not a surprise given only 52 mantissa bits are available. Therefore // redo the calculation using 128-bit numbers. (64 bits are not enough). // Start out with digits rounded down; maybe add one below. - dddddd = static_cast(d64k / 65536); + dddddd = static_cast(d64k / 65536); // mantissa is a 64-bit integer representing M.mmm... * 2^63. The actual // value we're representing, of course, is M.mmm... * 2^exp2. @@ -461,7 +461,7 @@ static ExpDigits SplitToSix(const double value) { } } else { // Here, we are not close to the edge. - dddddd = static_cast((d64k + 32768) / 65536); + dddddd = static_cast((d64k + 32768) / 65536); } if (dddddd == 1000000) { dddddd = 100000; @@ -469,7 +469,7 @@ static ExpDigits SplitToSix(const double value) { } exp_dig.exponent = exp; - uint32_t two_digits = dddddd / 10000; + int two_digits = dddddd / 10000; dddddd -= two_digits * 10000; numbers_internal::PutTwoDigits(two_digits, &exp_dig.digits[0]); @@ -499,7 +499,7 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { if (std::signbit(d)) *out++ = '-'; *out++ = '0'; *out = 0; - return static_cast(out - buffer); + return out - buffer; } if (d < 0) { *out++ = '-'; @@ -507,7 +507,7 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { } if (d > std::numeric_limits::max()) { strcpy(out, "inf"); // NOLINT(runtime/printf) - return static_cast(out + 3 - buffer); + return out + 3 - buffer; } auto exp_dig = SplitToSix(d); @@ -519,7 +519,7 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { case 5: memcpy(out, &digits[0], 6), out += 6; *out = 0; - return static_cast(out - buffer); + return out - buffer; case 4: memcpy(out, &digits[0], 5), out += 5; if (digits[5] != '0') { @@ -527,7 +527,7 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { *out++ = digits[5]; } *out = 0; - return static_cast(out - buffer); + return out - buffer; case 3: memcpy(out, &digits[0], 4), out += 4; if ((digits[5] | digits[4]) != '0') { @@ -536,7 +536,7 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { if (digits[5] != '0') *out++ = digits[5]; } *out = 0; - return static_cast(out - buffer); + return out - buffer; case 2: memcpy(out, &digits[0], 3), out += 3; *out++ = '.'; @@ -545,7 +545,7 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { while (out[-1] == '0') --out; if (out[-1] == '.') --out; *out = 0; - return static_cast(out - buffer); + return out - buffer; case 1: memcpy(out, &digits[0], 2), out += 2; *out++ = '.'; @@ -554,7 +554,7 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { while (out[-1] == '0') --out; if (out[-1] == '.') --out; *out = 0; - return static_cast(out - buffer); + return out - buffer; case 0: memcpy(out, &digits[0], 1), out += 1; *out++ = '.'; @@ -563,7 +563,7 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { while (out[-1] == '0') --out; if (out[-1] == '.') --out; *out = 0; - return static_cast(out - buffer); + return out - buffer; case -4: out[2] = '0'; ++out; @@ -582,7 +582,7 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { out += 6; while (out[-1] == '0') --out; *out = 0; - return static_cast(out - buffer); + return out - buffer; } assert(exp < -4 || exp >= 6); out[0] = digits[0]; @@ -601,12 +601,12 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) { if (exp > 99) { int dig1 = exp / 100; exp -= dig1 * 100; - *out++ = '0' + static_cast(dig1); + *out++ = '0' + dig1; } - PutTwoDigits(static_cast(exp), out); + PutTwoDigits(exp, out); out += 2; *out = 0; - return static_cast(out - buffer); + return out - buffer; } namespace { @@ -642,12 +642,10 @@ inline bool safe_parse_sign_and_base(absl::string_view* text /*inout*/, int base = *base_ptr; // Consume whitespace. - while (start < end && - absl::ascii_isspace(static_cast(start[0]))) { + while (start < end && absl::ascii_isspace(start[0])) { ++start; } - while (start < end && - absl::ascii_isspace(static_cast(end[-1]))) { + while (start < end && absl::ascii_isspace(end[-1])) { --end; } if (start >= end) { @@ -696,7 +694,7 @@ inline bool safe_parse_sign_and_base(absl::string_view* text /*inout*/, } else { return false; } - *text = absl::string_view(start, static_cast(end - start)); + *text = absl::string_view(start, end - start); *base_ptr = base; return true; } @@ -922,18 +920,17 @@ inline bool safe_parse_positive_int(absl::string_view text, int base, const IntType vmax = std::numeric_limits::max(); assert(vmax > 0); assert(base >= 0); - const IntType base_inttype = static_cast(base); - assert(vmax >= base_inttype); + assert(vmax >= static_cast(base)); const IntType vmax_over_base = LookupTables::kVmaxOverBase[base]; assert(base < 2 || - std::numeric_limits::max() / base_inttype == vmax_over_base); + std::numeric_limits::max() / base == vmax_over_base); const char* start = text.data(); const char* end = start + text.size(); // loop over digits for (; start < end; ++start) { unsigned char c = static_cast(start[0]); - IntType digit = static_cast(kAsciiToInt[c]); - if (digit >= base_inttype) { + int digit = kAsciiToInt[c]; + if (digit >= base) { *value_p = value; return false; } @@ -941,7 +938,7 @@ inline bool safe_parse_positive_int(absl::string_view text, int base, *value_p = vmax; return false; } - value *= base_inttype; + value *= base; if (value > vmax - digit) { *value_p = vmax; return false; diff --git a/absl/strings/str_cat.cc b/absl/strings/str_cat.cc index 2f9df673..f4a77493 100644 --- a/absl/strings/str_cat.cc +++ b/absl/strings/str_cat.cc @@ -56,7 +56,7 @@ AlphaNum::AlphaNum(Dec dec) { *--writer = '0' + (value % 10); value /= 10; } - *--writer = '0' + static_cast(value); + *--writer = '0' + value; if (neg) *--writer = '-'; ptrdiff_t fillers = writer - minfill; @@ -73,7 +73,7 @@ AlphaNum::AlphaNum(Dec dec) { if (add_sign_again) *--writer = '-'; } - piece_ = absl::string_view(writer, static_cast(end - writer)); + piece_ = absl::string_view(writer, end - writer); } // ---------------------------------------------------------------------- diff --git a/absl/strings/string_view.cc b/absl/strings/string_view.cc index e2261625..adce3be9 100644 --- a/absl/strings/string_view.cc +++ b/absl/strings/string_view.cc @@ -32,7 +32,7 @@ void WritePadding(std::ostream& o, size_t pad) { memset(fill_buf, o.fill(), sizeof(fill_buf)); while (pad) { size_t n = std::min(pad, sizeof(fill_buf)); - o.write(fill_buf, static_cast(n)); + o.write(fill_buf, n); pad -= n; } } @@ -63,7 +63,7 @@ std::ostream& operator<<(std::ostream& o, string_view piece) { size_t lpad = 0; size_t rpad = 0; if (static_cast(o.width()) > piece.size()) { - size_t pad = static_cast(o.width()) - piece.size(); + size_t pad = o.width() - piece.size(); if ((o.flags() & o.adjustfield) == o.left) { rpad = pad; } else { @@ -71,7 +71,7 @@ std::ostream& operator<<(std::ostream& o, string_view piece) { } } if (lpad) WritePadding(o, lpad); - o.write(piece.data(), static_cast(piece.size())); + o.write(piece.data(), piece.size()); if (rpad) WritePadding(o, rpad); o.width(0); } @@ -86,7 +86,7 @@ string_view::size_type string_view::find(string_view s, } const char* result = strings_internal::memmatch(ptr_ + pos, length_ - pos, s.ptr_, s.length_); - return result ? static_cast(result - ptr_) : npos; + return result ? result - ptr_ : npos; } string_view::size_type string_view::find(char c, size_type pos) const noexcept { @@ -95,7 +95,7 @@ string_view::size_type string_view::find(char c, size_type pos) const noexcept { } const char* result = static_cast(memchr(ptr_ + pos, c, length_ - pos)); - return result != nullptr ? static_cast(result - ptr_) : npos; + return result != nullptr ? result - ptr_ : npos; } string_view::size_type string_view::rfind(string_view s, @@ -104,7 +104,7 @@ string_view::size_type string_view::rfind(string_view s, if (s.empty()) return std::min(length_, pos); const char* last = ptr_ + std::min(length_ - s.length_, pos) + s.length_; const char* result = std::find_end(ptr_, last, s.ptr_, s.ptr_ + s.length_); - return result != last ? static_cast(result - ptr_) : npos; + return result != last ? result - ptr_ : npos; } // Search range is [0..pos] inclusive. If pos == npos, search everything. diff --git a/absl/strings/substitute.cc b/absl/strings/substitute.cc index 33a39305..8980b198 100644 --- a/absl/strings/substitute.cc +++ b/absl/strings/substitute.cc @@ -40,8 +40,7 @@ void SubstituteAndAppendArray(std::string* output, absl::string_view format, absl::CEscape(format).c_str()); #endif return; - } else if (absl::ascii_isdigit( - static_cast(format[i + 1]))) { + } else if (absl::ascii_isdigit(format[i + 1])) { int index = format[i + 1] - '0'; if (static_cast(index) >= num_args) { #ifndef NDEBUG @@ -81,7 +80,7 @@ void SubstituteAndAppendArray(std::string* output, absl::string_view format, char* target = &(*output)[original_size]; for (size_t i = 0; i < format.size(); i++) { if (format[i] == '$') { - if (absl::ascii_isdigit(static_cast(format[i + 1]))) { + if (absl::ascii_isdigit(format[i + 1])) { const absl::string_view src = args_array[format[i + 1] - '0']; target = std::copy(src.begin(), src.end(), target); ++i; // Skip next char. @@ -111,8 +110,7 @@ Arg::Arg(const void* value) { } while (num != 0); *--ptr = 'x'; *--ptr = '0'; - piece_ = absl::string_view( - ptr, static_cast(scratch_ + sizeof(scratch_) - ptr)); + piece_ = absl::string_view(ptr, scratch_ + sizeof(scratch_) - ptr); } } @@ -134,7 +132,7 @@ Arg::Arg(Hex hex) { beg = writer; } - piece_ = absl::string_view(beg, static_cast(end - beg)); + piece_ = absl::string_view(beg, end - beg); } // TODO(jorg): Don't duplicate so much code between here and str_cat.cc @@ -149,7 +147,7 @@ Arg::Arg(Dec dec) { *--writer = '0' + (value % 10); value /= 10; } - *--writer = '0' + static_cast(value); + *--writer = '0' + value; if (neg) *--writer = '-'; ptrdiff_t fillers = writer - minfill; @@ -166,7 +164,7 @@ Arg::Arg(Dec dec) { if (add_sign_again) *--writer = '-'; } - piece_ = absl::string_view(writer, static_cast(end - writer)); + piece_ = absl::string_view(writer, end - writer); } } // namespace substitute_internal -- cgit v1.2.3