Summary:
This allows folly to compile with warnings 4245, 4287 and 4365 enabled, all of which are sign mismatch warnings.
This is labeled as 'mostly' because I'll probably have to clean up a few more of these.
Reviewed By: yfeldblum
Differential Revision:
D4263259
fbshipit-source-id:
0db618f0405817503a63094edd75b24ec1e5c9ad
31 files changed:
-#define FB_GEN(t, fn) \
-template<> inline t EndianIntBase<t>::swap(t x) { return fn(x); }
+#define FB_GEN(t, fn) \
+ template <> \
+ inline t EndianIntBase<t>::swap(t x) { \
+ return t(fn(std::make_unsigned<t>::type(x))); \
+ }
// fn(x) expands to (x) if the second argument is empty, which is exactly
// what we want for [u]int8_t. Also, gcc 4.7 on Intel doesn't have
// fn(x) expands to (x) if the second argument is empty, which is exactly
// what we want for [u]int8_t. Also, gcc 4.7 on Intel doesn't have
char buffer[20];
if (value < 0) {
result->push_back('-');
char buffer[20];
if (value < 0) {
result->push_back('-');
- result->append(buffer, uint64ToBufferUnsafe(-uint64_t(value), buffer));
+ result->append(
+ buffer, uint64ToBufferUnsafe(uint64_t(-uint64_t(value)), buffer));
- result->append(buffer, uint64ToBufferUnsafe(value, buffer));
+ result->append(buffer, uint64ToBufferUnsafe(uint64_t(value), buffer));
conv.ToShortest(value, &builder);
break;
case DoubleToStringConverter::FIXED:
conv.ToShortest(value, &builder);
break;
case DoubleToStringConverter::FIXED:
- conv.ToFixed(value, numDigits, &builder);
+ conv.ToFixed(value, int(numDigits), &builder);
break;
default:
CHECK(mode == DoubleToStringConverter::PRECISION);
break;
default:
CHECK(mode == DoubleToStringConverter::PRECISION);
- conv.ToPrecision(value, numDigits, &builder);
+ conv.ToPrecision(value, int(numDigits), &builder);
- const size_t length = builder.position();
+ const size_t length = size_t(builder.position());
builder.Finalize();
result->append(buffer, length);
}
builder.Finalize();
result->append(buffer, length);
}
// so 21 is the longest non-exponential number > 1.
detail::kConvMaxDecimalInShortestHigh
});
// so 21 is the longest non-exponential number > 1.
detail::kConvMaxDecimalInShortestHigh
});
- return kMaxPositiveSpace + (value < 0); // +1 for minus sign, if negative
+ return size_t(
+ kMaxPositiveSpace +
+ (value < 0 ? 1 : 0)); // +1 for minus sign, if negative
const int n = reg[0];
if (n >= 1) {
__cpuid(static_cast<int*>(reg), 1);
const int n = reg[0];
if (n >= 1) {
__cpuid(static_cast<int*>(reg), 1);
- f1c_ = reg[2];
- f1d_ = reg[3];
+ f1c_ = uint32_t(reg[2]);
+ f1d_ = uint32_t(reg[3]);
}
if (n >= 7) {
__cpuidex(static_cast<int*>(reg), 7, 0);
}
if (n >= 7) {
__cpuidex(static_cast<int*>(reg), 7, 0);
- f7b_ = reg[1];
- f7c_ = reg[2];
+ f7b_ = uint32_t(reg[1]);
+ f7c_ = uint32_t(reg[2]);
}
#elif defined(__i386__) && defined(__PIC__) && !defined(__clang__) && \
defined(__GNUC__)
}
#elif defined(__i386__) && defined(__PIC__) && !defined(__clang__) && \
defined(__GNUC__)
inline void podFill(Pod* b, Pod* e, T c) {
FBSTRING_ASSERT(b && e && b <= e);
/*static*/ if (sizeof(T) == 1) {
inline void podFill(Pod* b, Pod* e, T c) {
FBSTRING_ASSERT(b && e && b <= e);
/*static*/ if (sizeof(T) == 1) {
+ memset(b, c, size_t(e - b));
} else {
auto const ee = b + ((e - b) & ~7u);
for (; b != ee; b += 8) {
} else {
auto const ee = b + ((e - b) & ~7u);
for (; b != ee; b += 8) {
// Specialization for const char*, const char*
FOLLY_MALLOC_NOINLINE
basic_fbstring(const value_type* b, const value_type* e, const A& /*a*/ = A())
// Specialization for const char*, const char*
FOLLY_MALLOC_NOINLINE
basic_fbstring(const value_type* b, const value_type* e, const A& /*a*/ = A())
+ : store_(b, size_type(e - b)) {
}
// Nonstandard constructor
}
// Nonstandard constructor
}
#elif defined(_MSC_VER)
// MSVC doesn't define __ostream_insert
}
#elif defined(_MSC_VER)
// MSVC doesn't define __ostream_insert
- os.write(str.data(), str.size());
+ os.write(str.data(), std::streamsize(str.size()));
#else
std::__ostream_insert(os, str.data(), str.size());
#endif
#else
std::__ostream_insert(os, str.data(), str.size());
#endif
S_destroy_range_a(*this, b_, e_);
}
S_destroy_range_a(*this, b_, e_);
}
- D_deallocate(b_, z_ - b_);
+ D_deallocate(b_, size_type(z_ - b_));
public:
size_type size() const noexcept {
public:
size_type size() const noexcept {
- return impl_.e_ - impl_.b_;
+ return size_type(impl_.e_ - impl_.b_);
}
size_type max_size() const noexcept {
}
size_type max_size() const noexcept {
}
size_type capacity() const noexcept {
}
size_type capacity() const noexcept {
- return impl_.z_ - impl_.b_;
+ return size_type(impl_.z_ - impl_.b_);
}
bool empty() const noexcept {
}
bool empty() const noexcept {
- M_deallocate(impl_.b_, impl_.z_ - impl_.b_);
+ M_deallocate(impl_.b_, size_type(impl_.z_ - impl_.b_));
impl_.z_ = newB + newCap;
impl_.e_ = newB + (impl_.e_ - impl_.b_);
impl_.b_ = newB;
impl_.z_ = newB + newCap;
impl_.e_ = newB + (impl_.e_ - impl_.b_);
impl_.b_ = newB;
auto p = s.begin();
auto end = s.end();
while (p != end) {
auto p = s.begin();
auto end = s.end();
while (p != end) {
- auto q = static_cast<const char*>(memchr(p, '}', end - p));
+ auto q = static_cast<const char*>(memchr(p, '}', size_t(end - p)));
if (!q) {
out(StringPiece(p, end));
break;
if (!q) {
out(StringPiece(p, end));
break;
bool hasDefaultArgIndex = false;
bool hasExplicitArgIndex = false;
while (p != end) {
bool hasDefaultArgIndex = false;
bool hasExplicitArgIndex = false;
while (p != end) {
- auto q = static_cast<const char*>(memchr(p, '{', end - p));
+ auto q = static_cast<const char*>(memchr(p, '{', size_t(end - p)));
if (!q) {
outputString(StringPiece(p, end));
break;
if (!q) {
outputString(StringPiece(p, end));
break;
- q = static_cast<const char*>(memchr(p, '}', end - p));
+ q = static_cast<const char*>(memchr(p, '}', size_t(end - p)));
if (q == nullptr) {
throw BadFormatArg("folly::format: missing ending '}'");
}
if (q == nullptr) {
throw BadFormatArg("folly::format: missing ending '}'");
}
arg.enforce(arg.widthIndex == FormatArg::kNoIndex,
"cannot provide width arg index without value arg index");
int sizeArg = nextArg++;
arg.enforce(arg.widthIndex == FormatArg::kNoIndex,
"cannot provide width arg index without value arg index");
int sizeArg = nextArg++;
- arg.width = getSizeArg(sizeArg, arg);
+ arg.width = getSizeArg(size_t(sizeArg), arg);
if (arg.width == FormatArg::kDynamicWidth) {
arg.enforce(arg.widthIndex != FormatArg::kNoIndex,
"cannot provide value arg index without width arg index");
if (arg.width == FormatArg::kDynamicWidth) {
arg.enforce(arg.widthIndex != FormatArg::kNoIndex,
"cannot provide value arg index without width arg index");
- arg.width = getSizeArg(arg.widthIndex, arg);
+ arg.width = getSizeArg(size_t(arg.widthIndex), arg);
"folly::format: may not have both default and explicit arg indexes");
}
"folly::format: may not have both default and explicit arg indexes");
}
- doFormat(argIndex, arg, out);
+ doFormat(size_t(argIndex), arg, out);
if (arg.precision != FormatArg::kDefaultPrecision &&
val.size() > static_cast<size_t>(arg.precision)) {
if (arg.precision != FormatArg::kDefaultPrecision &&
val.size() > static_cast<size_t>(arg.precision)) {
- val.reset(val.data(), arg.precision);
+ val.reset(val.data(), size_t(arg.precision));
}
constexpr int padBufSize = 128;
}
constexpr int padBufSize = 128;
auto pad = [&padBuf, &cb, padBufSize] (int chars) {
while (chars) {
int n = std::min(chars, padBufSize);
auto pad = [&padBuf, &cb, padBufSize] (int chars) {
while (chars) {
int n = std::min(chars, padBufSize);
- cb(StringPiece(padBuf, n));
+ cb(StringPiece(padBuf, size_t(n)));
val.size() < static_cast<size_t>(arg.width)) {
char fill = arg.fill == FormatArg::kDefaultFill ? ' ' : arg.fill;
int padChars = static_cast<int> (arg.width - val.size());
val.size() < static_cast<size_t>(arg.width)) {
char fill = arg.fill == FormatArg::kDefaultFill ? ' ' : arg.fill;
int padChars = static_cast<int> (arg.width - val.size());
- memset(padBuf, fill, std::min(padBufSize, padChars));
+ memset(padBuf, fill, size_t(std::min(padBufSize, padChars)));
switch (arg.align) {
case FormatArg::Align::DEFAULT:
switch (arg.align) {
case FormatArg::Align::DEFAULT:
arg.align = FormatArg::Align::RIGHT;
} else if (prefixLen && arg.align == FormatArg::Align::PAD_AFTER_SIGN) {
// Split off the prefix, then do any padding if necessary
arg.align = FormatArg::Align::RIGHT;
} else if (prefixLen && arg.align == FormatArg::Align::PAD_AFTER_SIGN) {
// Split off the prefix, then do any padding if necessary
- cb(val.subpiece(0, prefixLen));
- val.advance(prefixLen);
+ cb(val.subpiece(0, size_t(prefixLen)));
+ val.advance(size_t(prefixLen));
arg.width = std::max(arg.width - prefixLen, 0);
}
format_value::formatString(val, arg, cb);
arg.width = std::max(arg.width - prefixLen, 0);
}
format_value::formatString(val, arg, cb);
char sign;
if (std::is_signed<T>::value) {
if (folly::is_negative(val_)) {
char sign;
if (std::is_signed<T>::value) {
if (folly::is_negative(val_)) {
- uval = -static_cast<UT>(val_);
+ uval = UT(-static_cast<UT>(val_));
sign = '-';
} else {
uval = static_cast<UT>(val_);
sign = '-';
} else {
uval = static_cast<UT>(val_);
+ uval = static_cast<UT>(val_);
sign = '\0';
arg.enforce(arg.sign == FormatArg::Sign::DEFAULT,
sign = '\0';
arg.enforce(arg.sign == FormatArg::Sign::DEFAULT,
int len = snprintf(valBufBegin, (valBuf + valBufSize) - valBufBegin,
"%" PRIuMAX, static_cast<uintmax_t>(uval));
#else
int len = snprintf(valBufBegin, (valBuf + valBufSize) - valBufBegin,
"%" PRIuMAX, static_cast<uintmax_t>(uval));
#else
- int len = snprintf(valBufBegin, (valBuf + valBufSize) - valBufBegin,
- "%ju", static_cast<uintmax_t>(uval));
+ int len = snprintf(
+ valBufBegin,
+ size_t((valBuf + valBufSize) - valBufBegin),
+ "%ju",
+ static_cast<uintmax_t>(uval));
#endif
// valBufSize should always be big enough, so this should never
// happen.
#endif
// valBufSize should always be big enough, so this should never
// happen.
"invalid specifier '", arg.presentation, "'");
format_value::formatString(val_, arg, cb);
} else {
"invalid specifier '", arg.presentation, "'");
format_value::formatString(val_, arg, cb);
} else {
- FormatValue<char>(val_.at(arg.splitIntKey())).format(arg, cb);
+ FormatValue<char>(val_.at(size_t(arg.splitIntKey()))).format(arg, cb);
template<bool containerMode, class... Args>
std::ostream& operator<<(std::ostream& out,
const Formatter<containerMode, Args...>& formatter) {
template<bool containerMode, class... Args>
std::ostream& operator<<(std::ostream& out,
const Formatter<containerMode, Args...>& formatter) {
- auto writer = [&out] (StringPiece sp) { out.write(sp.data(), sp.size()); };
+ auto writer = [&out](StringPiece sp) {
+ out.write(sp.data(), std::streamsize(sp.size()));
+ };
formatter(writer);
return out;
}
formatter(writer);
return out;
}
const char* p;
if (e[-1] == ']') {
--e;
const char* p;
if (e[-1] == ']') {
--e;
- p = static_cast<const char*>(memchr(b, '[', e - b));
+ p = static_cast<const char*>(memchr(b, '[', size_t(e - b)));
enforce(p, "unmatched ']'");
} else {
enforce(p, "unmatched ']'");
} else {
- p = static_cast<const char*>(memchr(b, '.', e - b));
+ p = static_cast<const char*>(memchr(b, '.', size_t(e - b)));
}
if (p) {
key_.assign(p + 1, e);
}
if (p) {
key_.assign(p + 1, e);
* buffer of size bytes.
*/
static size_t partialCount(const char* p, size_t size) {
* buffer of size bytes.
*/
static size_t partialCount(const char* p, size_t size) {
+ uint8_t v = uint8_t(*p);
size_t s = kHeaderSize;
s += 1 + b0key(v);
if (s > size) return 0;
size_t s = kHeaderSize;
s += 1 + b0key(v);
if (s > size) return 0;
* return the number of bytes used by the encoding.
*/
static size_t encodedSize(const char* p) {
* return the number of bytes used by the encoding.
*/
static size_t encodedSize(const char* p) {
- return (kHeaderSize + kGroupSize +
- b0key(*p) + b1key(*p) + b2key(*p) + b3key(*p));
+ return kHeaderSize + kGroupSize +
+ b0key(uint8_t(*p)) + b1key(uint8_t(*p)) +
+ b2key(uint8_t(*p)) + b3key(uint8_t(*p));
* that we must be able to read at least 17 bytes from the input pointer, p.
*/
static const char* decode(const char* p, uint32_t* dest) {
* that we must be able to read at least 17 bytes from the input pointer, p.
*/
static const char* decode(const char* p, uint32_t* dest) {
+ uint8_t key = uint8_t(p[0]);
__m128i val = _mm_loadu_si128((const __m128i*)(p+1));
__m128i mask =
_mm_load_si128((const __m128i*)&detail::groupVarintSSEMasks[key * 2]);
__m128i val = _mm_loadu_si128((const __m128i*)(p+1));
__m128i mask =
_mm_load_si128((const __m128i*)&detail::groupVarintSSEMasks[key * 2]);
*/
static const char* decode(const char* p, uint32_t* a, uint32_t* b,
uint32_t* c, uint32_t* d) {
*/
static const char* decode(const char* p, uint32_t* a, uint32_t* b,
uint32_t* c, uint32_t* d) {
+ uint8_t key = uint8_t(p[0]);
__m128i val = _mm_loadu_si128((const __m128i*)(p+1));
__m128i mask =
_mm_load_si128((const __m128i*)&detail::groupVarintSSEMasks[key * 2]);
__m128i val = _mm_loadu_si128((const __m128i*)(p+1));
__m128i mask =
_mm_load_si128((const __m128i*)&detail::groupVarintSSEMasks[key * 2]);
// Extracting 32 bits at a time out of an XMM register is a SSE4 feature
#if FOLLY_SSE >= 4
// Extracting 32 bits at a time out of an XMM register is a SSE4 feature
#if FOLLY_SSE >= 4
- *a = _mm_extract_epi32(r, 0);
- *b = _mm_extract_epi32(r, 1);
- *c = _mm_extract_epi32(r, 2);
- *d = _mm_extract_epi32(r, 3);
+ *a = uint32_t(_mm_extract_epi32(r, 0));
+ *b = uint32_t(_mm_extract_epi32(r, 1));
+ *c = uint32_t(_mm_extract_epi32(r, 2));
+ *d = uint32_t(_mm_extract_epi32(r, 3));
#else /* !__SSE4__ */
*a = _mm_extract_epi16(r, 0) + (_mm_extract_epi16(r, 1) << 16);
*b = _mm_extract_epi16(r, 2) + (_mm_extract_epi16(r, 3) << 16);
#else /* !__SSE4__ */
*a = _mm_extract_epi16(r, 0) + (_mm_extract_epi16(r, 1) << 16);
*b = _mm_extract_epi16(r, 2) + (_mm_extract_epi16(r, 3) << 16);
*/
static size_t size(uint64_t a, uint64_t b, uint64_t c, uint64_t d,
uint64_t e) {
*/
static size_t size(uint64_t a, uint64_t b, uint64_t c, uint64_t d,
uint64_t e) {
- return (kHeaderSize + kGroupSize +
- key(a) + key(b) + key(c) + key(d) + key(e));
+ return kHeaderSize + kGroupSize +
+ key(a) + key(b) + key(c) + key(d) + key(e);
*/
static size_t encodedSize(const char* p) {
uint16_t n = loadUnaligned<uint16_t>(p);
*/
static size_t encodedSize(const char* p) {
uint16_t n = loadUnaligned<uint16_t>(p);
- return (kHeaderSize + kGroupSize +
- b0key(n) + b1key(n) + b2key(n) + b3key(n) + b4key(n));
+ return kHeaderSize + kGroupSize +
+ b0key(n) + b1key(n) + b2key(n) + b3key(n) + b4key(n);
*/
static char* encode(char* p, uint64_t a, uint64_t b, uint64_t c,
uint64_t d, uint64_t e) {
*/
static char* encode(char* p, uint64_t a, uint64_t b, uint64_t c,
uint64_t d, uint64_t e) {
- uint8_t b0key = key(a);
- uint8_t b1key = key(b);
- uint8_t b2key = key(c);
- uint8_t b3key = key(d);
- uint8_t b4key = key(e);
+ uint16_t b0key = key(a);
+ uint16_t b1key = key(b);
+ uint16_t b2key = key(c);
+ uint16_t b3key = key(d);
+ uint16_t b4key = key(e);
storeUnaligned<uint16_t>(
p,
storeUnaligned<uint16_t>(
p,
- (b4key << 12) | (b3key << 9) | (b2key << 6) | (b1key << 3) | b0key);
+ uint16_t(
+ (b4key << 12) |
+ (b3key << 9) |
+ (b2key << 6) |
+ (b1key << 3) |
+ b0key));
p += 2;
storeUnaligned(p, a);
p += b0key+1;
p += 2;
storeUnaligned(p, a);
p += b0key+1;
return uint8_t(7 - (__builtin_clzll(x | 1) / 8));
}
return uint8_t(7 - (__builtin_clzll(x | 1) / 8));
}
- static uint8_t b0key(uint16_t x) { return x & 7; }
- static uint8_t b1key(uint16_t x) { return (x >> 3) & 7; }
- static uint8_t b2key(uint16_t x) { return (x >> 6) & 7; }
- static uint8_t b3key(uint16_t x) { return (x >> 9) & 7; }
- static uint8_t b4key(uint16_t x) { return (x >> 12) & 7; }
+ static uint8_t b0key(uint16_t x) { return x & 7u; }
+ static uint8_t b1key(uint16_t x) { return (x >> 3) & 7u; }
+ static uint8_t b2key(uint16_t x) { return (x >> 6) & 7u; }
+ static uint8_t b3key(uint16_t x) { return (x >> 9) & 7u; }
+ static uint8_t b4key(uint16_t x) { return (x >> 12) & 7u; }
static const uint64_t kMask[];
};
static const uint64_t kMask[];
};
if (pushes == nextPushes) {
// pushTicket_ didn't change from A (or the previous C) to C,
// so we can linearize at B (or D)
if (pushes == nextPushes) {
// pushTicket_ didn't change from A (or the previous C) to C,
// so we can linearize at B (or D)
+ return ssize_t(pushes - pops);
}
pushes = nextPushes;
uint64_t nextPops = popTicket_.load(std::memory_order_acquire); // D
if (pops == nextPops) {
// popTicket_ didn't chance from B (or the previous D), so we
// can linearize at C
}
pushes = nextPushes;
uint64_t nextPops = popTicket_.load(std::memory_order_acquire); // D
if (pops == nextPops) {
// popTicket_ didn't chance from B (or the previous D), so we
// can linearize at C
+ return ssize_t(pushes - pops);
#ifdef RW_SPINLOCK_USE_SSE_INSTRUCTIONS_
static __m128i make128(const uint16_t v[4]) {
#ifdef RW_SPINLOCK_USE_SSE_INSTRUCTIONS_
static __m128i make128(const uint16_t v[4]) {
- return _mm_set_epi16(0, 0, 0, 0, v[3], v[2], v[1], v[0]);
+ return _mm_set_epi16(0, 0, 0, 0,
+ short(v[3]), short(v[2]), short(v[1]), short(v[0]));
}
static inline __m128i fromInteger(uint64_t from) {
}
static inline __m128i fromInteger(uint64_t from) {
- return _mm_cvtsi64_si128(from);
+ return _mm_cvtsi64_si128(int64_t(from));
}
static inline uint64_t toInteger(__m128i in) {
}
static inline uint64_t toInteger(__m128i in) {
- return _mm_cvtsi128_si64(in);
+ return uint64_t(_mm_cvtsi128_si64(in));
}
static inline uint64_t addParallel(__m128i in, __m128i kDelta) {
return toInteger(_mm_add_epi16(in, kDelta));
}
static inline uint64_t addParallel(__m128i in, __m128i kDelta) {
return toInteger(_mm_add_epi16(in, kDelta));
#ifdef RW_SPINLOCK_USE_SSE_INSTRUCTIONS_
static __m128i make128(const uint8_t v[4]) {
#ifdef RW_SPINLOCK_USE_SSE_INSTRUCTIONS_
static __m128i make128(const uint8_t v[4]) {
- return _mm_set_epi8(0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, v[3], v[2], v[1], v[0]);
+ return _mm_set_epi8(
+ 0, 0, 0, 0,
+ 0, 0, 0, 0,
+ 0, 0, 0, 0,
+ char(v[3]), char(v[2]), char(v[1]), char(v[0]));
}
static inline __m128i fromInteger(uint32_t from) {
}
static inline __m128i fromInteger(uint32_t from) {
- return _mm_cvtsi32_si128(from);
+ return _mm_cvtsi32_si128(int32_t(from));
}
static inline uint32_t toInteger(__m128i in) {
}
static inline uint32_t toInteger(__m128i in) {
- return _mm_cvtsi128_si32(in);
+ return uint32_t(_mm_cvtsi128_si32(in));
}
static inline uint32_t addParallel(__m128i in, __m128i kDelta) {
return toInteger(_mm_add_epi8(in, kDelta));
}
static inline uint32_t addParallel(__m128i in, __m128i kDelta) {
return toInteger(_mm_add_epi8(in, kDelta));
void getSlow(unsigned char* data, size_t size);
inline size_t remaining() const {
void getSlow(unsigned char* data, size_t size);
inline size_t remaining() const {
- return buffer_.get() + bufferSize_ - ptr_;
+ return size_t(buffer_.get() + bufferSize_ - ptr_);
}
const size_t bufferSize_;
}
const size_t bufferSize_;
// Unfortunately current gcc versions have a bug causing it to reject
// this check in a constexpr function:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71448
// Unfortunately current gcc versions have a bug causing it to reject
// this check in a constexpr function:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71448
+ return size_type(e_ - b_);
}
constexpr size_type walk_size() const {
return std::distance(b_, e_);
}
constexpr size_type walk_size() const {
return std::distance(b_, e_);
inline std::ostream& operator<<(std::ostream& os,
const StringPiece piece) {
inline std::ostream& operator<<(std::ostream& os,
const StringPiece piece) {
- os.write(piece.start(), piece.size());
+ os.write(piece.start(), std::streamsize(piece.size()));
return os;
}
inline std::ostream& operator<<(std::ostream& os,
const MutableStringPiece piece) {
return os;
}
inline std::ostream& operator<<(std::ostream& os,
const MutableStringPiece piece) {
- os.write(piece.start(), piece.size());
+ os.write(piece.start(), std::streamsize(piece.size()));
// Check if done searching
if (++j == nsize) {
// Yay
// Check if done searching
if (++j == nsize) {
// Yay
- return i - haystack.begin();
+ return size_t(i - haystack.begin());
// * is a not-very-regular mix of 1's and 0's
// * does not need any other special mathematical properties
//
// * is a not-very-regular mix of 1's and 0's
// * does not need any other special mathematical properties
//
- static const uint64_t sc_const = 0xdeadbeefdeadbeefLL;
+ static const uint64_t sc_const = 0xdeadbeefdeadbeefULL;
uint64_t m_data[2*sc_numVars]; // unhashed data, for partial messages
uint64_t m_state[sc_numVars]; // internal state of the hash
uint64_t m_data[2*sc_numVars]; // unhashed data, for partial messages
uint64_t m_state[sc_numVars]; // internal state of the hash
// * is a not-very-regular mix of 1's and 0's
// * does not need any other special mathematical properties
//
// * is a not-very-regular mix of 1's and 0's
// * does not need any other special mathematical properties
//
- static constexpr uint64_t sc_const = 0xdeadbeefdeadbeefLL;
+ static constexpr uint64_t sc_const = 0xdeadbeefdeadbeefULL;
uint64_t m_data[2*sc_numVars]; // unhashed data, for partial messages
uint64_t m_state[sc_numVars]; // internal state of the hash
uint64_t m_data[2*sc_numVars]; // unhashed data, for partial messages
uint64_t m_state[sc_numVars]; // internal state of the hash
piece->end(),
[](char c) { return c != ' ' && c != '\t'; });
if (needle != piece->end()) {
piece->end(),
[](char c) { return c != ' ' && c != '\t'; });
if (needle != piece->end()) {
- indent = std::min<size_t>(indent, needle - piece->begin());
+ indent = std::min<size_t>(indent, size_t(needle - piece->begin()));
} else {
max_length = std::max<size_t>(piece->size(), max_length);
}
} else {
max_length = std::max<size_t>(piece->size(), max_length);
}
// (see Bits.cpp)
#ifdef _MSC_VER
inline int popcount(unsigned int x) {
// (see Bits.cpp)
#ifdef _MSC_VER
inline int popcount(unsigned int x) {
+ return int(__popcnt(x));
}
inline int popcountll(unsigned long long x) {
return int(__popcnt64(x));
}
inline int popcountll(unsigned long long x) {
return int(__popcnt64(x));
template <class F, class... Offset>
ssize_t wrapvFull(F f, int fd, iovec* iov, int count, Offset... offset) {
ssize_t totalBytes = 0;
template <class F, class... Offset>
ssize_t wrapvFull(F f, int fd, iovec* iov, int count, Offset... offset) {
ssize_t totalBytes = 0;
do {
r = f(fd, iov, std::min<int>(count, kIovMax), offset...);
do {
r = f(fd, iov, std::min<int>(count, kIovMax), offset...);
if (errno == EINTR) {
continue;
}
if (errno == EINTR) {
continue;
}
totalBytes += r;
incr(r, offset...);
while (r != 0 && count != 0) {
totalBytes += r;
incr(r, offset...);
while (r != 0 && count != 0) {
- if (r >= iov->iov_len) {
- r -= iov->iov_len;
+ if (r >= ssize_t(iov->iov_len)) {
+ r -= ssize_t(iov->iov_len);
template <>
struct GroupVarintTraits<uint32_t> {
template <>
struct GroupVarintTraits<uint32_t> {
kGroupSize = 4,
kHeaderSize = 1,
};
kGroupSize = 4,
kHeaderSize = 1,
};
template <>
struct GroupVarintTraits<uint64_t> {
template <>
struct GroupVarintTraits<uint64_t> {
kGroupSize = 5,
kHeaderSize = 2,
};
kGroupSize = 5,
kHeaderSize = 2,
};
class GroupVarintBase {
protected:
typedef GroupVarintTraits<T> Traits;
class GroupVarintBase {
protected:
typedef GroupVarintTraits<T> Traits;
- enum { kHeaderSize = Traits::kHeaderSize };
+ enum : uint32_t { kHeaderSize = Traits::kHeaderSize };
/**
* Number of integers encoded / decoded in one pass.
*/
/**
* Number of integers encoded / decoded in one pass.
*/
- enum { kGroupSize = Traits::kGroupSize };
+ enum : uint32_t { kGroupSize = Traits::kGroupSize };
/**
* Maximum encoded size.
*/
/**
* Maximum encoded size.
*/
- enum { kMaxSize = kHeaderSize + sizeof(type) * kGroupSize };
+ enum : uint32_t { kMaxSize = kHeaderSize + sizeof(type) * kGroupSize };
/**
* Maximum size for n values.
/**
* Maximum size for n values.
const StringPieceLite needles) {
SparseByteSet s;
for (auto needle: needles) {
const StringPieceLite needles) {
SparseByteSet s;
for (auto needle: needles) {
+ s.add(uint8_t(needle));
}
for (size_t index = 0; index < haystack.size(); ++index) {
}
for (size_t index = 0; index < haystack.size(); ++index) {
- if (s.contains(haystack[index])) {
+ if (s.contains(uint8_t(haystack[index]))) {
const char* data() const { return b_; }
const char* begin() const { return b_; }
const char* end() const { return e_; }
const char* data() const { return b_; }
const char* begin() const { return b_; }
const char* end() const { return e_; }
- size_t size() const { return e_ - b_; }
+ size_t size() const { return size_t(e_ - b_); }
bool empty() const { return size() == 0; }
const char& operator[](size_t i) const { DCHECK_GT(size(), i); return b_[i]; }
template <typename Range>
bool empty() const { return size() == 0; }
const char& operator[](size_t i) const { DCHECK_GT(size(), i); return b_[i]; }
template <typename Range>
/// Returns the bitmask to pass futexWait or futexWake when communicating
/// about the specified turn
/// Returns the bitmask to pass futexWait or futexWake when communicating
/// about the specified turn
- int futexChannel(uint32_t turn) const noexcept { return 1 << (turn & 31); }
+ uint32_t futexChannel(uint32_t turn) const noexcept {
+ return 1u << (turn & 31);
+ }
uint32_t decodeCurrentSturn(uint32_t state) const noexcept {
return state & ~kWaitersMask;
uint32_t decodeCurrentSturn(uint32_t state) const noexcept {
return state & ~kWaitersMask;
template<class T, class NumericType /* = typename NumericTypeHelper<T>::type */>
dynamic::dynamic(T t) {
type_ = TypeInfo<NumericType>::type;
template<class T, class NumericType /* = typename NumericTypeHelper<T>::type */>
dynamic::dynamic(T t) {
type_ = TypeInfo<NumericType>::type;
- new (getAddress<NumericType>()) NumericType(t);
+ new (getAddress<NumericType>()) NumericType(NumericType(t));
}
template <class Iterator>
}
template <class Iterator>
}
inline std::size_t dynamic::count(dynamic const& key) const {
}
inline std::size_t dynamic::count(dynamic const& key) const {
- return find(key) != items().end();
+ return find(key) != items().end() ? 1u : 0u;
}
inline dynamic::const_item_iterator dynamic::find(dynamic const& key) const {
}
inline dynamic::const_item_iterator dynamic::find(dynamic const& key) const {
asm ("popcntq %1, %0" : "=r" (result) : "r" (value));
return result;
#else
asm ("popcntq %1, %0" : "=r" (result) : "r" (value));
return result;
#else
- return _mm_popcnt_u64(value);
+ return uint64_t(_mm_popcnt_u64(value));
if (value.type() != type_) {
return none;
}
if (value.type() != type_) {
return none;
}
- if (!Comparison()(length_, value.size())) {
+ if (!Comparison()(size_t(length_), value.size())) {
return makeError("different length string/array/object", value);
}
return none;
return makeError("different length string/array/object", value);
}
return none;
fiber == NO_WAITER &&
waitingFiber_.compare_exchange_strong(fiber, THREAD_WAITING))) {
do {
fiber == NO_WAITER &&
waitingFiber_.compare_exchange_strong(fiber, THREAD_WAITING))) {
do {
- folly::detail::MemoryIdler::futexWait(futex_.futex, THREAD_WAITING);
+ folly::detail::MemoryIdler::futexWait(
+ futex_.futex, uint32_t(THREAD_WAITING));
fiber = waitingFiber_.load(std::memory_order_acquire);
} while (fiber == THREAD_WAITING);
}
fiber = waitingFiber_.load(std::memory_order_acquire);
} while (fiber == THREAD_WAITING);
}
auto deadline = TimeoutController::Clock::now() + timeout;
do {
const auto wait_rv =
auto deadline = TimeoutController::Clock::now() + timeout;
do {
const auto wait_rv =
- futex_.futex.futexWaitUntil(THREAD_WAITING, deadline);
+ futex_.futex.futexWaitUntil(uint32_t(THREAD_WAITING), deadline);
if (wait_rv == folly::detail::FutexResult::TIMEDOUT) {
return false;
}
if (wait_rv == folly::detail::FutexResult::TIMEDOUT) {
return false;
}
class Semaphore {
public:
explicit Semaphore(size_t tokenCount)
class Semaphore {
public:
explicit Semaphore(size_t tokenCount)
- : capacity_(tokenCount), tokens_(capacity_) {}
+ : capacity_(tokenCount), tokens_(int64_t(capacity_)) {}
Semaphore(const Semaphore&) = delete;
Semaphore(Semaphore&&) = delete;
Semaphore(const Semaphore&) = delete;
Semaphore(Semaphore&&) = delete;
if (n == 0) {
return true;
}
if (n == 0) {
return true;
}
- if (!body(ByteRange(buffer_->tail(), n))) {
+ if (!body(ByteRange(buffer_->tail(), size_t(n)))) {
throw std::system_error(errno, std::system_category(),
"write() failed");
}
throw std::system_error(errno, std::system_category(),
"write() failed");
}
* Returns the number of bytes in the buffer before the start of the data.
*/
uint64_t headroom() const {
* Returns the number of bytes in the buffer before the start of the data.
*/
uint64_t headroom() const {
- return data_ - buffer();
+ return uint64_t(data_ - buffer());
* Returns the number of bytes in the buffer after the end of the data.
*/
uint64_t tailroom() const {
* Returns the number of bytes in the buffer after the end of the data.
*/
uint64_t tailroom() const {
- return bufferEnd() - tail();
+ return uint64_t(bufferEnd() - tail());
recordAndPos_ = std::make_pair(ByteRange(), off_t(-1));
range_.clear(); // at end
} else {
recordAndPos_ = std::make_pair(ByteRange(), off_t(-1));
range_.clear(); // at end
} else {
- size_t skipped = record.begin() - range_.begin();
+ size_t skipped = size_t(record.begin() - range_.begin());
DCHECK_GE(skipped, headerSize());
skipped -= headerSize();
range_.advance(skipped);
DCHECK_GE(skipped, headerSize());
skipped -= headerSize();
range_.advance(skipped);
out.push_back(hexDigit(v & 0x0f));
} else if (*p == '\\' || *p == '\"') {
out.push_back('\\');
out.push_back(hexDigit(v & 0x0f));
} else if (*p == '\\' || *p == '\"') {
out.push_back('\\');
+ out.push_back(char(*p++));
} else if (*p <= 0x1f) {
switch (*p) {
case '\b': out.append("\\b"); p++; break;
} else if (*p <= 0x1f) {
switch (*p) {
case '\b': out.append("\\b"); p++; break;