enable signed conversion warning

Author: jhunsaker

CMakeLists.txt

@@ -15,7 +15,7 @@ set( CMAKE_INCLUDE_CURRENT_DIR ON )
 include_directories( program/src/ )
 
 # gcc compiler/linker flags
-add_compile_options( -ggdb -Wall -Wextra -Werror -m64 )
+add_compile_options( -ggdb -Wall -Wextra -Wsign-conversion -Werror -m64 )
 set( CMAKE_CXX_FLAGS -std=c++11 )
 set( CMAKE_C_FLAGS -std=c99 )
 set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pthread")

pc/bincode.hpp

@@ -100,7 +100,7 @@ namespace pc
 
   inline void bincode::add( uint8_t val )
   {
-    buf_[idx_++] = val;
+    add_val_T( val );
   }
 
   template<class T>

pc/capture.cpp

@@ -155,7 +155,7 @@ void capture::run()
           int num = ::gzwrite( zfd_, buf, sz );
           if ( num > 0 ) {
             buf += num;
-            sz  -= num;
+            sz  -= static_cast< unsigned >( num );
           } else {
             break;
           }

pc/key_pair.cpp

@@ -4,6 +4,8 @@
 #include "misc.hpp"
 #include <openssl/evp.h>
 
+#include <assert.h>
+
 #define PC_SYMBOL_SPACES 0x2020202020202020
 
 using namespace pc;
@@ -75,20 +77,21 @@ void hash::init_from_buf( const uint8_t *pk )
   __builtin_memcpy( pk_, pk, len );
 }
 
-int hash::enc_base58( uint8_t *buf, uint32_t buflen ) const
+int hash::enc_base58( char *buf, int buflen ) const
 {
   return pc::enc_base58( pk_, len, buf, buflen );
 }
 
 int hash::enc_base58( std::string& res ) const
 {
   char buf[64];
-  int n = enc_base58( (uint8_t*)buf, 64 );
-  res.assign( buf, n );
+  int n = enc_base58( buf, 64 );
+  assert( n >= 0 );
+  res.assign( buf, static_cast< unsigned >( n ) );
   return n;
 }
 
-int hash::dec_base58( const uint8_t *buf, uint32_t buflen )
+int hash::dec_base58( const uint8_t *buf, int buflen )
 {
   return pc::dec_base58( buf, buflen, pk_ );
 }
@@ -197,16 +200,17 @@ bool signature::init_from_text( const std::string& buf )
   return true;
 }
 
-int signature::enc_base58( uint8_t *buf, uint32_t buflen )
+int signature::enc_base58( char *buf, int buflen )
 {
   return pc::enc_base58( sig_, len, buf, buflen );
 }
 
 int signature::enc_base58( std::string& res )
 {
   char buf[256];
-  int n = enc_base58( (uint8_t*)buf, 256 );
-  res.assign( buf, n );
+  int n = enc_base58( buf, 256 );
+  assert( n >= 0 );
+  res.assign( buf, static_cast< unsigned >( n ) );
   return n;
 }
 

pc/key_pair.hpp

@@ -25,9 +25,9 @@ namespace pc
     void init_from_buf( const uint8_t * );
 
     // encode to text buffer
-    int enc_base58( uint8_t *buf, uint32_t buflen ) const;
+    int enc_base58( char *buf, int buflen ) const;
     int enc_base58( std::string& ) const;
-    int dec_base58( const uint8_t *buf, uint32_t buflen );
+    int dec_base58( const uint8_t *buf, int buflen );
 
     // get underlying bytes
     const uint8_t *data() const;
@@ -96,7 +96,7 @@ namespace pc
     bool init_from_text( const std::string& buf );
 
     // encode to text buffer
-    int enc_base58( uint8_t *buf, uint32_t buflen );
+    int enc_base58( char *buf, int buflen );
     int enc_base58( std::string& );
 
     // sign message given key_pair

pc/key_store.cpp

@@ -27,7 +27,7 @@ static bool write_key_file(
       hd->dealloc();
       return false;
     }
-    len -= num;
+    len -= static_cast< unsigned >( num );
     buf += num;
   } while( len );
   fchmod( fd, 0400 );

pc/manager.cpp

@@ -498,8 +498,10 @@ void manager::poll_schedule()
 {
   while ( is_pub_ && kidx_ < kvec_.size() ) {
     price_sched *kptr = kvec_[kidx_];
-    int64_t pub_ts = pub_ts_ + ( pub_int_ * kptr->get_hash() ) /
-      price_sched::fraction;
+    int64_t pub_ts = pub_ts_ + static_cast< int64_t >(
+      ( static_cast< uint64_t >( pub_int_ ) * kptr->get_hash() )
+        / price_sched::fraction
+    );
     if ( curr_ts_ > pub_ts ) {
       kptr->schedule();
       if ( ++kidx_ >= kvec_.size() ) {

pc/mem_map.cpp

@@ -1,4 +1,6 @@
 #include "mem_map.hpp"
+
+#include <assert.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
@@ -47,7 +49,8 @@ bool mem_map::remap()
   if ( 0 != fstat( fd_, fst ) || fst->st_size == 0 ) {
     return false;
   }
-  size_t nlen = fst->st_size;
+  assert( fst->st_size >= 0 );
+  size_t nlen = static_cast< size_t >( fst->st_size );
   if ( nlen == len_ ) {
     return false;
   }
@@ -72,7 +75,8 @@ bool mem_map::init()
     ::close( fd );
     return false;
   }
-  len_ = fst->st_size;
+  assert( fst->st_size >= 0 );
+  len_ = static_cast< size_t >( fst->st_size );
   void *buf = mmap( NULL, len_, PROT_READ, MAP_SHARED, fd, 0 );
   if ( buf == MAP_FAILED ) {
     return false;

pc/misc.cpp

@@ -1,4 +1,6 @@
 #include "misc.hpp"
+
+#include <assert.h>
 #include <ctype.h>
 #include <time.h>
 
@@ -29,18 +31,24 @@ const char ALPHABET_MAP[256] = {
 const double iFactor = 1.36565823730976103695740418120764243208481439700722980119458355862779176747360903943915516885072037696111192757109;
 
 // reslen is the allocated length for result, feel free to overallocate
-int enc_base58(const uint8_t *source, int len, uint8_t result[], int reslen) {
+int enc_base58(const uint8_t *source, int len, char result[], int reslen)
+{
+  assert( source );
+  assert( len >= 0 );
+  assert( reslen >= 0 );
+
   int zeros = 0, length = 0, pbegin = 0, pend;
   if (!(pend = len)) return 0;
   while (pbegin != pend && !source[pbegin]) pbegin = ++zeros;
   int size = 1 + iFactor * (double)(pend - pbegin);
-  uint8_t b58[size];
+  assert( size > 0 );
+  uint8_t b58[ static_cast< unsigned >( size ) ];
   for (int i = 0; i < size; i++) b58[i] = 0;
   while (pbegin != pend) {
     uint32_t carry = source[pbegin];
     int i = 0;
     for (int it1 = size - 1; (carry || i < length) && (it1 != -1); it1--,i++) {
-      carry += 256 * b58[it1];
+      carry += 256U * b58[it1];
       b58[it1] = carry % 58;
       carry /= 58;
     }
@@ -61,6 +69,10 @@ int enc_base58(const uint8_t *source, int len, uint8_t result[], int reslen) {
 // result must be declared (for the worst case): char result[len * 2];
 int dec_base58( const uint8_t *str, int len, uint8_t *result)
 {
+  assert( str );
+  assert( len >= 0 );
+  assert( result );
+
   result[0] = 0;
   int resultlen = 1;
   for (int i = 0; i < len; i++) {
@@ -105,15 +117,15 @@ char *uint_to_str( uint64_t val, char *cptr )
   return cptr;
 }
 
-uint64_t str_to_uint( const char *val, int len )
+uint64_t str_to_uint( const char *val, const unsigned len )
 {
   uint64_t res = 0L;
   if ( len ) {
     const char *cptr = val;
     const char *end = &val[len];
     for(; cptr != end; ++cptr ) {
       if ( isdigit( *cptr ) ) {
-        res = res*10UL + (*cptr-'0');
+        res = res*10UL + static_cast< unsigned >(*cptr-'0');
       } else {
         res = 0L;
         break;
@@ -143,7 +155,7 @@ char *int_to_str( int64_t val, char *cptr )
   return cptr;
 }
 
-int64_t str_to_int( const char *val, int len )
+int64_t str_to_int( const char *val, const unsigned len )
 {
   bool is_neg = false;
   int64_t res = 0L;
@@ -152,7 +164,7 @@ int64_t str_to_int( const char *val, int len )
     const char *end = &val[len];
     for(; cptr != end; ++cptr ) {
       if ( isdigit( *cptr ) ) {
-        res = res*10UL + (*cptr-'0');
+        res = res*10L + (*cptr-'0');
       } else if ( *cptr == '-' ) {
         is_neg = true;
       } else {
@@ -181,14 +193,14 @@ inline void a3_to_a4(uint8_t* a4, uint8_t* a3)
   a4[3] = (a3[2] & 0x3f);
 }
 
-inline void a4_to_a3( uint8_t* a3, uint8_t* a4)
+inline void a4_to_a3( uint8_t* a3, const uint8_t* a4)
 {
   a3[0] = (a4[0] << 2) + ((a4[1] & 0x30) >> 4);
   a3[1] = ((a4[1] & 0xf) << 4) + ((a4[2] & 0x3c) >> 2);
   a3[2] = ((a4[2] & 0x3) << 6) + a4[3];
 }
 
-inline uint8_t b64_lookup(char c)
+inline char b64_lookup(char c)
 {
   if(c >='A' && c <='Z') return c - 'A';
   if(c >='a' && c <='z') return c - 71;
@@ -198,14 +210,15 @@ inline uint8_t b64_lookup(char c)
   return -1;
 }
 
-int enc_base64_len( int n )
+size_t enc_base64_len( const size_t n )
 {
   return (n + 2 - ((n + 2) % 3)) / 3 * 4;
 }
 
-int enc_base64( const uint8_t *inp, int len, uint8_t *out )
+size_t enc_base64( const uint8_t *inp, int len, char *out )
 {
-  int i = 0, j = 0, encLen = 0;
+  int i = 0, j = 0;
+  size_t encLen = 0;
   uint8_t a3[3];
   uint8_t a4[4];
 
@@ -236,22 +249,23 @@ int enc_base64( const uint8_t *inp, int len, uint8_t *out )
   return encLen;
 }
 
-int dec_base64( const uint8_t *inp, int len, uint8_t *out )
+size_t dec_base64( const char *inp, int len, uint8_t *out )
 {
-  int i = 0, j = 0, decLen = 0;
+  int i = 0, j = 0;
+  size_t decLen = 0;
   uint8_t a3[3] = { 0,0,0 };
-  uint8_t a4[4];
+  char a4[4];
 
   while ( len-- ) {
     if(*inp == '=') {
       break;
     }
     a4[i++] = *(inp++);
     if (i == 4) {
-      for (i = 0; i <4; i++) {
+      for (i = 0; i < 4; i++) {
         a4[i] = b64_lookup(a4[i]);
       }
-      a4_to_a3(a3,a4);
+      a4_to_a3( a3, reinterpret_cast< uint8_t* >( a4 ) );
       for (i = 0; i < 3; i++) {
         out[decLen++] = a3[i];
       }
@@ -266,7 +280,7 @@ int dec_base64( const uint8_t *inp, int len, uint8_t *out )
     for (j = 0; j <4; j++) {
       a4[j] = b64_lookup(a4[j]);
     }
-    a4_to_a3(a3,a4);
+    a4_to_a3( a3, reinterpret_cast< uint8_t* >( a4 ) );
     for (j = 0; j < i - 1; j++) {
       out[decLen++] = a3[j];
     }
@@ -279,7 +293,7 @@ int64_t get_now()
   struct timespec ts[1];
   clock_gettime( CLOCK_REALTIME, ts );
   int64_t res = ts->tv_sec;
-  res *= 1000000000UL;
+  res *= 1000000000L;
   res += ts->tv_nsec;
   return res;
 }

pc/misc.hpp

@@ -13,20 +13,20 @@ namespace pc
 {
 
   // base58 encoding from base-x conversion impl.
-  int enc_base58( const uint8_t *src, int len, uint8_t *result, int rlen);
+  int enc_base58( const uint8_t *src, int len, char *result, int rlen);
   int dec_base58( const uint8_t *str, int len, uint8_t *result );
 
   // base64 encoding courtesy of
   // Adam Rudd per licence: github.com/adamvr/arduino-base64
-  int enc_base64_len( int len );
-  int enc_base64( const uint8_t *src, int len, uint8_t *result );
-  int dec_base64( const uint8_t *str, int len, uint8_t *result );
+  size_t enc_base64_len( size_t len );
+  size_t enc_base64( const uint8_t *src, int len, char *result );
+  size_t dec_base64( const char *str, int len, uint8_t *result );
 
   // integer to string encoding
   char *uint_to_str( uint64_t val, char *end_ptr );
-  uint64_t str_to_uint( const char *str, int len );
+  uint64_t str_to_uint( const char *str, unsigned len );
   char *int_to_str( int64_t val, char *end_ptr );
-  int64_t str_to_int( const char *str, int len );
+  int64_t str_to_int( const char *str, unsigned len );
 
   // string representation of decimal to integer with implied decimal places
   int64_t str_to_dec( const char *str, int len, int expo );