Skip to content

Commit 26ea20b

Browse files
drewdzzzdrewdzzz
committed
build: support -Wconversion warning
1 parent 91f242d commit 26ea20b

27 files changed

+146
-207
lines changed

‎CMakeLists.txt

+1
Original file line numberDiff line numberDiff line change
@@ -141,6 +141,7 @@ FUNCTION (TNTCXX_TEST)
141141
TARGET_COMPILE_DEFINITIONS(${TNTCXX_TEST_NAME} PRIVATE ${TNTCXX_TEST_DEFINES})
142142
IF (${TNTCXX_TEST_TYPE} STREQUAL "ctest")
143143
ADD_TEST(NAME ${TNTCXX_TEST_NAME} COMMAND ${TNTCXX_TEST_NAME})
144+
TARGET_COMPILE_OPTIONS(${TNTCXX_TEST_NAME} PRIVATE -Wconversion)
144145
ENDIF()
145146
ENDFUNCTION()
146147

‎src/Buffer/Buffer.hpp

+8-8
Original file line numberDiff line numberDiff line change
@@ -801,7 +801,7 @@ Buffer<N, allocator>::dropBack(size_t size)
801801
assert(!m_blocks.isEmpty());
802802

803803
Block *block = &m_blocks.last();
804-
size_t left_in_block = m_end - block->begin();
804+
size_t left_in_block = static_cast<size_t>(m_end - block->begin());
805805

806806
/* Do not delete the block if it is empty after drop. */
807807
while (TNT_UNLIKELY(size > left_in_block)) {
@@ -842,7 +842,7 @@ Buffer<N, allocator>::dropFront(size_t size)
842842
assert(!m_blocks.isEmpty());
843843

844844
Block *block = &m_blocks.first();
845-
size_t left_in_block = block->end() - m_begin;
845+
size_t left_in_block = static_cast<size_t>(block->end() - m_begin);
846846

847847
while (TNT_UNLIKELY(size >= left_in_block)) {
848848
#ifndef NDEBUG
@@ -918,8 +918,8 @@ Buffer<N, allocator>::insert(const iterator &itr, size_t size)
918918
*/
919919
#define src_block_begin ((src_block == itr.getBlock()) ? itr.m_position : src_block->begin())
920920
/* Firstly move data in blocks. */
921-
size_t left_in_dst_block = m_end - dst_block->begin();
922-
size_t left_in_src_block = src_block_end - src_block_begin;
921+
size_t left_in_dst_block = static_cast<size_t>(m_end - dst_block->begin());
922+
size_t left_in_src_block = static_cast<size_t>(src_block_end - src_block_begin);
923923
if (left_in_dst_block > left_in_src_block) {
924924
src = src_block_begin;
925925
dst = m_end - left_in_src_block;
@@ -943,7 +943,7 @@ Buffer<N, allocator>::insert(const iterator &itr, size_t size)
943943
break;
944944
src_block = &src_block->prev();
945945
src = src_block->end() - left_in_dst_block;
946-
left_in_src_block = src_block->end() - src_block_begin;
946+
left_in_src_block = static_cast<size_t>(src_block->end() - src_block_begin);
947947
dst = dst_block->begin();
948948
copy_chunk_sz = left_in_dst_block;
949949
} else {
@@ -978,14 +978,14 @@ Buffer<N, allocator>::release(const iterator &itr, size_t size)
978978
size_t step = size;
979979
assert(src_block->end() > src);
980980
while (step >= (size_t)(src_block->end() - src)) {
981-
step -= src_block->end() - src;
981+
step -= static_cast<size_t>(src_block->end() - src);
982982
src_block = &src_block->next();
983983
src = src_block->begin();
984984
}
985985
src += step;
986986
/* Firstly move data in blocks. */
987-
size_t left_in_dst_block = dst_block->end() - dst;
988-
size_t left_in_src_block = src_block->end() - src;
987+
size_t left_in_dst_block = static_cast<size_t>(dst_block->end() - dst);
988+
size_t left_in_src_block = static_cast<size_t>(src_block->end() - src);
989989
size_t copy_chunk_sz = std::min(left_in_src_block, left_in_dst_block);
990990
for (;;) {
991991
std::memmove(dst, src, copy_chunk_sz);

‎src/Client/Connection.hpp

+8-7
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,7 @@
4242
/** rid == request id */
4343
typedef size_t rid_t;
4444

45-
static constexpr size_t CONN_READAHEAD = 64 * 1024;
45+
static constexpr ssize_t CONN_READAHEAD = 64 * 1024;
4646
static constexpr size_t IOVEC_MAX_SIZE = 32;
4747

4848
struct ConnectionError {
@@ -249,7 +249,7 @@ class Connection
249249

250250
private:
251251
ConnectionImpl<BUFFER, NetProvider> *impl;
252-
static constexpr size_t GC_STEP_CNT = 100;
252+
static constexpr int GC_STEP_CNT = 100;
253253

254254
template <class T>
255255
rid_t insert(const T &tuple, uint32_t space_id);
@@ -549,16 +549,17 @@ processResponse(Connection<BUFFER, NetProvider> &conn,
549549
std::abort();
550550

551551
}
552-
response.size += MP_RESPONSE_SIZE;
553-
if (! conn.impl->inBuf.has(conn.impl->endDecoded, response.size)) {
552+
response.size += static_cast<int>(MP_RESPONSE_SIZE);
553+
uint32_t size = static_cast<uint32_t>(response.size);
554+
if (! conn.impl->inBuf.has(conn.impl->endDecoded, size)) {
554555
//Response was received only partially. Reset decoder position
555556
//to the start of response to make this function re-entered.
556557
conn.impl->dec.reset(conn.impl->endDecoded);
557558
return DECODE_NEEDMORE;
558559
}
559560
if (conn.impl->dec.decodeResponse(response) != 0) {
560561
conn.setError("Failed to decode response, skipping bytes..");
561-
conn.impl->endDecoded += response.size;
562+
conn.impl->endDecoded += size;
562563
return DECODE_ERR;
563564
}
564565
LOG_DEBUG("Header: sync=", response.header.sync, ", code=",
@@ -569,7 +570,7 @@ processResponse(Connection<BUFFER, NetProvider> &conn,
569570
conn.impl->futures.insert({response.header.sync,
570571
std::move(response)});
571572
}
572-
conn.impl->endDecoded += response.size;
573+
conn.impl->endDecoded += size;
573574
inputBufGC(conn);
574575
return DECODE_SUCC;
575576
}
@@ -594,7 +595,7 @@ decodeGreeting(Connection<BUFFER, NetProvider> &conn)
594595
char hex_salt[Iproto::MAX_SALT_SIZE * 2 + 1];
595596
const char *hex = "0123456789abcdef";
596597
for (size_t i = 0; i < conn.impl->greeting.salt_size; i++) {
597-
uint8_t u = conn.impl->greeting.salt[i];
598+
uint8_t u = static_cast<uint8_t>(conn.impl->greeting.salt[i]);
598599
hex_salt[i * 2] = hex[u / 16];
599600
hex_salt[i * 2 + 1] = hex[u % 16];
600601
}

‎src/Client/LibevNetProvider.hpp

+3-2
Original file line numberDiff line numberDiff line change
@@ -129,7 +129,8 @@ connectionReceive(Connection<BUFFER, LibevNetProvider<BUFFER, Stream>> &conn)
129129
size_t iov_cnt = buf.getIOV(itr, iov, IOVEC_MAX_SIZE);
130130

131131
ssize_t rcvd = conn.get_strm().recv(iov, iov_cnt);
132-
hasNotRecvBytes(conn, CONN_READAHEAD - (rcvd < 0 ? 0 : rcvd));
132+
size_t bytes = static_cast<size_t>(CONN_READAHEAD - (rcvd < 0 ? 0 : rcvd));
133+
hasNotRecvBytes(conn, bytes);
133134
if (rcvd < 0) {
134135
conn.setError(std::string("Failed to receive response: ") +
135136
strerror(errno), errno);
@@ -213,7 +214,7 @@ connectionSend(Connection<BUFFER, LibevNetProvider<BUFFER, Stream>> &conn)
213214
assert(conn.get_strm().has_status(SS_NEED_EVENT_FOR_WRITE));
214215
return 1;
215216
} else {
216-
hasSentBytes(conn, sent);
217+
hasSentBytes(conn, static_cast<size_t>(sent));
217218
}
218219
}
219220
/* All data from connection has been successfully written. */

‎src/Client/RequestEncoder.hpp

+25-25
Original file line numberDiff line numberDiff line change
@@ -97,7 +97,7 @@ class RequestEncoder {
9797
const Greeting &greet);
9898

9999
/** Sync value is used as request id. */
100-
static size_t getSync() { return sync; }
100+
static size_t getSync() { return static_cast<size_t>(sync); }
101101
static constexpr size_t PREHEADER_SIZE = 5;
102102
private:
103103
void encodeHeader(int request);
@@ -124,9 +124,9 @@ RequestEncoder<BUFFER>::encodePing()
124124
m_Buf.write(uint32_t{0});
125125
encodeHeader(Iproto::PING);
126126
mpp::encode(m_Buf, mpp::as_map(std::make_tuple()));
127-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
127+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
128128
++request_start;
129-
request_start.set(__builtin_bswap32(request_size));
129+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
130130
return request_size + PREHEADER_SIZE;
131131
}
132132

@@ -142,9 +142,9 @@ RequestEncoder<BUFFER>::encodeInsert(const T &tuple, uint32_t space_id)
142142
mpp::encode(m_Buf, mpp::as_map(std::forward_as_tuple(
143143
MPP_AS_CONST(Iproto::SPACE_ID), space_id,
144144
MPP_AS_CONST(Iproto::TUPLE), tuple)));
145-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
145+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
146146
++request_start;
147-
request_start.set(__builtin_bswap32(request_size));
147+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
148148
return request_size + PREHEADER_SIZE;
149149
}
150150

@@ -160,9 +160,9 @@ RequestEncoder<BUFFER>::encodeReplace(const T &tuple, uint32_t space_id)
160160
mpp::encode(m_Buf, mpp::as_map(std::forward_as_tuple(
161161
MPP_AS_CONST(Iproto::SPACE_ID), space_id,
162162
MPP_AS_CONST(Iproto::TUPLE), tuple)));
163-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
163+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
164164
++request_start;
165-
request_start.set(__builtin_bswap32(request_size));
165+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
166166
return request_size + PREHEADER_SIZE;
167167
}
168168

@@ -180,9 +180,9 @@ RequestEncoder<BUFFER>::encodeDelete(const T &key, uint32_t space_id,
180180
MPP_AS_CONST(Iproto::SPACE_ID), space_id,
181181
MPP_AS_CONST(Iproto::INDEX_ID), index_id,
182182
MPP_AS_CONST(Iproto::KEY), key)));
183-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
183+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
184184
++request_start;
185-
request_start.set(__builtin_bswap32(request_size));
185+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
186186
return request_size + PREHEADER_SIZE;
187187
}
188188

@@ -201,9 +201,9 @@ RequestEncoder<BUFFER>::encodeUpdate(const K &key, const T &tuple,
201201
MPP_AS_CONST(Iproto::INDEX_ID), index_id,
202202
MPP_AS_CONST(Iproto::KEY), key,
203203
MPP_AS_CONST(Iproto::TUPLE), tuple)));
204-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
204+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
205205
++request_start;
206-
request_start.set(__builtin_bswap32(request_size));
206+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
207207
return request_size + PREHEADER_SIZE;
208208
}
209209

@@ -222,9 +222,9 @@ RequestEncoder<BUFFER>::encodeUpsert(const T &tuple, const O &ops,
222222
MPP_AS_CONST(Iproto::INDEX_BASE), index_base,
223223
MPP_AS_CONST(Iproto::OPS), ops,
224224
MPP_AS_CONST(Iproto::TUPLE), tuple)));
225-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
225+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
226226
++request_start;
227-
request_start.set(__builtin_bswap32(request_size));
227+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
228228
return request_size + PREHEADER_SIZE;
229229
}
230230

@@ -247,9 +247,9 @@ RequestEncoder<BUFFER>::encodeSelect(const T &key,
247247
MPP_AS_CONST(Iproto::OFFSET), offset,
248248
MPP_AS_CONST(Iproto::ITERATOR), iterator,
249249
MPP_AS_CONST(Iproto::KEY), key)));
250-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
250+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
251251
++request_start;
252-
request_start.set(__builtin_bswap32(request_size));
252+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
253253
return request_size + PREHEADER_SIZE;
254254
}
255255

@@ -266,9 +266,9 @@ RequestEncoder<BUFFER>::encodeExecute(const std::string& statement, const T& par
266266
MPP_AS_CONST(Iproto::SQL_TEXT), statement,
267267
MPP_AS_CONST(Iproto::SQL_BIND), parameters,
268268
MPP_AS_CONST(Iproto::OPTIONS), std::make_tuple())));
269-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
269+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
270270
++request_start;
271-
request_start.set(__builtin_bswap32(request_size));
271+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
272272
return request_size + PREHEADER_SIZE;
273273
}
274274

@@ -285,9 +285,9 @@ RequestEncoder<BUFFER>::encodeExecute(unsigned int stmt_id, const T& parameters)
285285
MPP_AS_CONST(Iproto::STMT_ID), stmt_id,
286286
MPP_AS_CONST(Iproto::SQL_BIND), parameters,
287287
MPP_AS_CONST(Iproto::OPTIONS), std::make_tuple())));
288-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
288+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
289289
++request_start;
290-
request_start.set(__builtin_bswap32(request_size));
290+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
291291
return request_size + PREHEADER_SIZE;
292292
}
293293

@@ -301,9 +301,9 @@ RequestEncoder<BUFFER>::encodePrepare(const std::string& statement)
301301
encodeHeader(Iproto::PREPARE);
302302
mpp::encode(m_Buf, mpp::as_map(std::forward_as_tuple(
303303
MPP_AS_CONST(Iproto::SQL_TEXT), statement)));
304-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
304+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
305305
++request_start;
306-
request_start.set(__builtin_bswap32(request_size));
306+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
307307
return request_size + PREHEADER_SIZE;
308308
}
309309

@@ -319,9 +319,9 @@ RequestEncoder<BUFFER>::encodeCall(const std::string &func, const T &args)
319319
mpp::encode(m_Buf, mpp::as_map(std::forward_as_tuple(
320320
MPP_AS_CONST(Iproto::FUNCTION_NAME), func,
321321
MPP_AS_CONST(Iproto::TUPLE), mpp::as_arr(args))));
322-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
322+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
323323
++request_start;
324-
request_start.set(__builtin_bswap32(request_size));
324+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
325325
return request_size + PREHEADER_SIZE;
326326
}
327327

@@ -342,9 +342,9 @@ RequestEncoder<BUFFER>::encodeAuth(std::string_view user,
342342
MPP_AS_CONST(Iproto::USER_NAME), user,
343343
MPP_AS_CONST(Iproto::TUPLE),
344344
std::make_tuple("chap-sha1", scram_str))));
345-
uint32_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
345+
size_t request_size = (m_Buf.end() - request_start) - PREHEADER_SIZE;
346346
++request_start;
347-
request_start.set(__builtin_bswap32(request_size));
347+
request_start.set(__builtin_bswap32(static_cast<uint32_t>(request_size)));
348348
return request_size + PREHEADER_SIZE;
349349
}
350350

‎src/Client/ResponseDecoder.hpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -136,7 +136,7 @@ parseGreeting(std::string_view raw, Greeting &greeting) {
136136
std::string_view salt_encoded = line2.substr(0, Iproto::GREETING_MAX_SALT_SIZE);
137137
char *out = base64::decode(salt_encoded.begin(), salt_encoded.end(),
138138
greeting.salt).second;
139-
greeting.salt_size = out - greeting.salt;
139+
greeting.salt_size = static_cast<size_t>(out - greeting.salt);
140140
assert(greeting.salt_size <= sizeof(greeting.salt));
141141
if (greeting.salt_size < Iproto::SCRAMBLE_SIZE)
142142
return -1;

‎src/Client/Stream.hpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -211,7 +211,7 @@ Stream::set_status(uint32_t st)
211211
else
212212
status |= st;
213213
assert(has_status(SS_ESTABLISHED) ||
214-
(status & ~SS_READINESS_STATUS) == 0);
214+
(status & ~unsigned(SS_READINESS_STATUS)) == 0);
215215
assert(!(has_status(SS_NEED_READ_EVENT_FOR_READ) &&
216216
has_status(SS_NEED_WRITE_EVENT_FOR_READ)));
217217
assert(!(has_status(SS_NEED_READ_EVENT_FOR_WRITE) &&

‎src/Client/UnixPlainStream.hpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -86,7 +86,7 @@ create_msghdr(struct iovec *iov, size_t iov_count)
8686
{
8787
struct msghdr msg{};
8888
msg.msg_iov = iov;
89-
msg.msg_iovlen = iov_count;
89+
msg.msg_iovlen = static_cast<int>(iov_count);
9090
return msg;
9191
}
9292
} // namespace internal

‎src/Client/UnixStream.hpp

+2-1
Original file line numberDiff line numberDiff line change
@@ -197,7 +197,8 @@ UnixStream::connect(const ConnectOptions &opts_arg)
197197
struct pollfd fds;
198198
fds.fd = fd;
199199
fds.events = POLLOUT;
200-
if (poll(&fds, 1, opts.connect_timeout) == 0) {
200+
int timeout = static_cast<int>(opts.connect_timeout);
201+
if (poll(&fds, 1, timeout) == 0) {
201202
connect_errno = ETIMEDOUT;
202203
break;
203204
}

‎src/Utils/Base64.hpp

+5-4
Original file line numberDiff line numberDiff line change
@@ -140,7 +140,8 @@ std::pair<INP, OUT> decode(INP first, INP last, OUT dest)
140140
if (BASE64_UNLIKELY(first == last))
141141
return {first, dest};
142142

143-
uint8_t c = decmap[static_cast<uint8_t>(*first)];
143+
uint8_t c = static_cast<uint8_t>(
144+
decmap[static_cast<uint8_t>(*first)]);
144145
if (BASE64_UNLIKELY(c >= 64)) // Bad char or '=' here is error.
145146
return {first, dest};
146147
uint32_t part = c; // 6 bits.
@@ -150,7 +151,7 @@ std::pair<INP, OUT> decode(INP first, INP last, OUT dest)
150151
if (BASE64_UNLIKELY(next == last)) // Unexpected end.
151152
return {first, dest};
152153

153-
c = decmap[static_cast<uint8_t>(*next)];
154+
c = static_cast<uint8_t>(decmap[static_cast<uint8_t>(*next)]);
154155
if (BASE64_UNLIKELY(c >= 64)) // Bad char or '=' here is error.
155156
return {first, dest};
156157

@@ -169,7 +170,7 @@ std::pair<INP, OUT> decode(INP first, INP last, OUT dest)
169170
return {next, dest};
170171
}
171172

172-
c = decmap[static_cast<uint8_t>(*next)];
173+
c = static_cast<uint8_t>(decmap[static_cast<uint8_t>(*next)]);
173174
if (BASE64_UNLIKELY(c >= 64)) {
174175
if (BASE64_UNLIKELY((part & 0xf) != 0))
175176
// Incorrect (non-zero) remainder.
@@ -201,7 +202,7 @@ std::pair<INP, OUT> decode(INP first, INP last, OUT dest)
201202
return {next, dest};
202203
}
203204

204-
c = decmap[static_cast<uint8_t>(*next)];
205+
c = static_cast<uint8_t>(decmap[static_cast<uint8_t>(*next)]);
205206
if (BASE64_UNLIKELY(c >= 64)) {
206207
if (BASE64_UNLIKELY((part & 0x3) != 0))
207208
// Incorrect (non-zero) remainder.

‎src/Utils/Mempool.hpp

+2-1
Original file line numberDiff line numberDiff line change
@@ -190,7 +190,8 @@ class MempoolInstance : public MempoolStats<ENABLE_STATS> {
190190

191191
size_t bc = Stats_t::statBlockCount();
192192
size_t total_block_count = sc * (M - 1);
193-
size_t prealloc = (m_SlabDataEnd - m_SlabDataBeg) / B;
193+
ptrdiff_t data_len = m_SlabDataEnd - m_SlabDataBeg;
194+
size_t prealloc = static_cast<size_t>(data_len) / B;
194195
size_t expect_free = total_block_count - prealloc - bc;
195196
if (calc_free_block_count != expect_free)
196197
res |= 2;

0 commit comments

Comments
 (0)