From 8ea3c136d6496fd9e005baf42a023b31a66321b7 Mon Sep 17 00:00:00 2001 From: Florin Iucha Date: Sun, 16 Dec 2018 01:30:22 -0500 Subject: [PATCH] Fix sign-conversion warnings in headers --- include/fmt/chrono.h | 2 +- include/fmt/format-inl.h | 4 +-- include/fmt/format.h | 69 +++++++++++++++++++++------------------- 3 files changed, 39 insertions(+), 36 deletions(-) diff --git a/include/fmt/chrono.h b/include/fmt/chrono.h index a964ea9396729..7a2bae0891b91 100644 --- a/include/fmt/chrono.h +++ b/include/fmt/chrono.h @@ -250,7 +250,7 @@ struct chrono_formatter { void write(int value, int width) { typedef typename int_traits::main_type main_type; main_type n = to_unsigned(value); - int num_digits = static_cast(internal::count_digits(n)); + int num_digits = internal::count_digits(n); if (width > num_digits) out = std::fill_n(out, width - num_digits, '0'); out = format_decimal(out, n, num_digits); diff --git a/include/fmt/format-inl.h b/include/fmt/format-inl.h index 69e9433184685..b34c7bbd1d13f 100644 --- a/include/fmt/format-inl.h +++ b/include/fmt/format-inl.h @@ -172,7 +172,7 @@ void format_error_code(internal::buffer &out, int error_code, abs_value = 0 - abs_value; ++error_code_size; } - error_code_size += internal::count_digits(abs_value); + error_code_size += static_cast(internal::count_digits(abs_value)); writer w(out); if (message.size() <= inline_buffer_size - error_code_size) { w.write(message); @@ -739,7 +739,7 @@ FMT_FUNC typename std::enable_if::type // hi (p1 in Grisu) contains the most significant digits of scaled_upper. // hi = floor(upper / one). uint32_t hi = static_cast(upper.f >> -one.e); - int exp = static_cast(count_digits(hi)); // kappa in Grisu. + int exp = count_digits(hi); // kappa in Grisu. gen_digits_params params = process_specs(specs, cached_exp + exp, buf); fp_value.normalize(); fp scaled_value = fp_value * cached_pow; diff --git a/include/fmt/format.h b/include/fmt/format.h index 8166e858c5a49..3b7a538b1689c 100644 --- a/include/fmt/format.h +++ b/include/fmt/format.h @@ -763,16 +763,16 @@ typedef basic_data<> data; #ifdef FMT_BUILTIN_CLZLL // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. -inline unsigned count_digits(uint64_t n) { +inline int count_digits(uint64_t n) { // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; - return to_unsigned(t) - (n < data::ZERO_OR_POWERS_OF_10_64[t]) + 1; + return t - (n < data::ZERO_OR_POWERS_OF_10_64[t]) + 1; } #else // Fallback version of count_digits used when __builtin_clz is not available. -inline unsigned count_digits(uint64_t n) { - unsigned count = 1; +inline int count_digits(uint64_t n) { + int count = 1; for (;;) { // Integer division is slow so do it for a group of four digits instead // of for every digit. The idea comes from the talk by Alexandrescu @@ -893,9 +893,9 @@ class decimal_formatter_null : public decimal_formatter { #ifdef FMT_BUILTIN_CLZ // Optional version of count_digits for better performance on 32-bit platforms. -inline unsigned count_digits(uint32_t n) { +inline int count_digits(uint32_t n) { int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; - return to_unsigned(t) - (n < data::ZERO_OR_POWERS_OF_10_32[t]) + 1; + return t - (n < data::ZERO_OR_POWERS_OF_10_32[t]) + 1; } #endif @@ -1006,7 +1006,7 @@ inline Char *format_uint(Char *buffer, UInt value, int num_digits, do { const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; unsigned digit = (value & ((1 << BASE_BITS) - 1)); - *--buffer = static_cast(BASE_BITS < 4 ? '0' + digit : digits[digit]); + *--buffer = static_cast(BASE_BITS < 4 ? static_cast('0' + digit) : digits[digit]); } while ((value >>= BASE_BITS) != 0); return end; } @@ -1961,7 +1961,9 @@ FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out) { template <> inline bool find( const char *first, const char *last, char value, const char *&out) { - out = static_cast(std::memchr(first, value, last - first)); + const ptrdiff_t length = last - first; + FMT_ASSERT(length >= 0, "invalid input range"); + out = static_cast(std::memchr(first, value, static_cast(length))); return out != FMT_NULL; } @@ -2041,10 +2043,11 @@ FMT_CONSTEXPR const typename ParseContext::char_type * template class format_string_checker { + enum { INVALID_ARG_ID = 0xffffffffu }; public: explicit FMT_CONSTEXPR format_string_checker( basic_string_view format_str, ErrorHandler eh) - : arg_id_(-1), context_(format_str, eh), + : arg_id_(INVALID_ARG_ID), context_(format_str, eh), parse_funcs_{&parse_format_specs...} {} FMT_CONSTEXPR void on_text(const Char *, const Char *) {} @@ -2064,7 +2067,7 @@ class format_string_checker { FMT_CONSTEXPR const Char *on_format_specs(const Char *begin, const Char *) { context_.advance_to(begin); - return to_unsigned(arg_id_) < NUM_ARGS ? + return arg_id_ < NUM_ARGS ? parse_funcs_[arg_id_](context_) : begin; } @@ -2077,14 +2080,14 @@ class format_string_checker { enum { NUM_ARGS = sizeof...(Args) }; FMT_CONSTEXPR void check_arg_id() { - if (internal::to_unsigned(arg_id_) >= NUM_ARGS) + if (arg_id_ >= NUM_ARGS) context_.on_error("argument index out of range"); } // Format specifier parsing function. typedef const Char *(*parse_func)(parse_context_type &); - int arg_id_; + unsigned arg_id_; parse_context_type context_; parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1]; }; @@ -2287,9 +2290,9 @@ class basic_writer { // // where are written by f(it). template - void write_int(unsigned num_digits, string_view prefix, + void write_int(int num_digits, string_view prefix, const Spec &spec, F f) { - std::size_t size = prefix.size() + num_digits; + std::size_t size = prefix.size() + static_cast(num_digits); char_type fill = static_cast(spec.fill()); std::size_t padding = 0; if (spec.align() == ALIGN_NUMERIC) { @@ -2297,9 +2300,9 @@ class basic_writer { padding = spec.width() - size; size = spec.width(); } - } else if (spec.precision > static_cast(num_digits)) { + } else if (spec.precision > num_digits) { size = prefix.size() + internal::to_unsigned(spec.precision); - padding = internal::to_unsigned(spec.precision) - num_digits; + padding = internal::to_unsigned(spec.precision - num_digits); fill = static_cast('0'); } align_spec as = spec; @@ -2316,8 +2319,8 @@ class basic_writer { bool is_negative = internal::is_negative(value); if (is_negative) abs_value = 0 - abs_value; - unsigned num_digits = internal::count_digits(abs_value); - auto &&it = reserve((is_negative ? 1 : 0) + num_digits); + int num_digits = internal::count_digits(abs_value); + auto &&it = reserve((is_negative ? 1 : 0) + static_cast(num_digits)); if (is_negative) *it++ = static_cast('-'); it = internal::format_decimal(it, abs_value, num_digits); @@ -2338,9 +2341,9 @@ class basic_writer { // Counts the number of digits in abs_value. BITS = log2(radix). template - unsigned count_digits() const { + int count_digits() const { unsigned_type n = abs_value; - unsigned num_digits = 0; + int num_digits = 0; do { ++num_digits; } while ((n >>= BITS) != 0); @@ -2362,7 +2365,7 @@ class basic_writer { struct dec_writer { unsigned_type abs_value; - unsigned num_digits; + int num_digits; template void operator()(It &&it) const { @@ -2371,14 +2374,14 @@ class basic_writer { }; void on_dec() { - unsigned num_digits = internal::count_digits(abs_value); + int num_digits = internal::count_digits(abs_value); writer.write_int(num_digits, get_prefix(), spec, dec_writer{abs_value, num_digits}); } struct hex_writer { int_writer &self; - unsigned num_digits; + int num_digits; template void operator()(It &&it) const { @@ -2392,7 +2395,7 @@ class basic_writer { prefix[prefix_size++] = '0'; prefix[prefix_size++] = static_cast(spec.type); } - unsigned num_digits = count_digits<4>(); + int num_digits = count_digits<4>(); writer.write_int(num_digits, get_prefix(), spec, hex_writer{*this, num_digits}); } @@ -2400,7 +2403,7 @@ class basic_writer { template struct bin_writer { unsigned_type abs_value; - unsigned num_digits; + int num_digits; template void operator()(It &&it) const { @@ -2413,15 +2416,15 @@ class basic_writer { prefix[prefix_size++] = '0'; prefix[prefix_size++] = static_cast(spec.type); } - unsigned num_digits = count_digits<1>(); + int num_digits = count_digits<1>(); writer.write_int(num_digits, get_prefix(), spec, bin_writer<1>{abs_value, num_digits}); } void on_oct() { - unsigned num_digits = count_digits<3>(); + int num_digits = count_digits<3>(); if (spec.has(HASH_FLAG) && - spec.precision <= static_cast(num_digits)) { + spec.precision <= num_digits) { // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. prefix[prefix_size++] = '0'; @@ -2434,7 +2437,7 @@ class basic_writer { struct num_writer { unsigned_type abs_value; - unsigned size; + int size; char_type sep; template @@ -2446,9 +2449,9 @@ class basic_writer { }; void on_num() { - unsigned num_digits = internal::count_digits(abs_value); + int num_digits = internal::count_digits(abs_value); char_type sep = internal::thousands_sep(writer.locale_); - unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3); + int size = num_digits + SEP_SIZE * ((num_digits - 1) / 3); writer.write_int(size, get_prefix(), spec, num_writer{abs_value, size, sep}); } @@ -2904,9 +2907,9 @@ inline void format_decimal(char *&buffer, T value) { *buffer++ = internal::data::DIGITS[index + 1]; return; } - unsigned num_digits = internal::count_digits(abs_value); + int num_digits = internal::count_digits(abs_value); internal::format_decimal( - internal::make_checked(buffer, num_digits), abs_value, num_digits); + internal::make_checked(buffer, static_cast(num_digits)), abs_value, num_digits); buffer += num_digits; }