9 files changed, 47 insertions, 44 deletions

diff --git a/xdelta3/Makefile.am b/xdelta3/Makefile.am
index 8283663..dd2f2d5 100644
--- a/xdelta3/Makefile.am
+++ b/xdelta3/Makefile.am
@@ -35,6 +35,8 @@ xdelta3regtest_SOURCES = $(common_SOURCES) \
         testing/sizes.h \
         testing/test.h
 
+# Note: for extra sanity checks, enable -Wconversion. Note there
+# are a lot of false positives.
 WFLAGS = -Wall -Wshadow -fno-builtin -Wextra -Wsign-compare \
          -Wextra -Wno-unused-parameter
 
diff --git a/xdelta3/xdelta3-blkcache.h b/xdelta3/xdelta3-blkcache.h
index 27263ed..f9f3d8a 100644
--- a/xdelta3/xdelta3-blkcache.h
+++ b/xdelta3/xdelta3-blkcache.h
@@ -303,7 +303,7 @@ main_getblk_lru (xd3_source *source, xoff_t blkno,
   lru_filled += 1;
   (*is_new) = 1;
   (*blrup) = blru;
-  blru->blkno = -1;
+  blru->blkno = (xoff_t) -1;
   return 0;
 }
 
@@ -384,7 +384,7 @@ main_read_seek_source (xd3_stream *stream,
       while (sfile->source_position < pos)
         {
           xoff_t skip_blkno;
-          usize_t skip_offset;
+          xoff_t skip_offset;
 
           xd3_blksize_div (sfile->source_position, source,
                            &skip_blkno, &skip_offset);
diff --git a/xdelta3/xdelta3-decode.h b/xdelta3/xdelta3-decode.h
index d468669..24665df 100644
--- a/xdelta3/xdelta3-decode.h
+++ b/xdelta3/xdelta3-decode.h
@@ -428,7 +428,7 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
                  * copy. */
                 xd3_source *source = stream->src;
                 xoff_t block = source->cpyoff_blocks;
-                usize_t blkoff = source->cpyoff_blkoff;
+                xoff_t blkoff = source->cpyoff_blkoff;
                 const xoff_t blksize = source->blksize;
                 int ret;
 
@@ -475,7 +475,7 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
                   }
                 else
                   {
-                    take = blksize - blkoff;
+                    take = (usize_t) (blksize - blkoff);
                     inst->size -= take;
                     inst->addr += take;
 
diff --git a/xdelta3/xdelta3-fgk.h b/xdelta3/xdelta3-fgk.h
index f145cc9..b85e2c2 100644
--- a/xdelta3/xdelta3-fgk.h
+++ b/xdelta3/xdelta3-fgk.h
@@ -191,7 +191,7 @@ static fgk_stream* fgk_alloc (xd3_stream *stream /*, int alphabet_size0 */)
 static int fgk_init (xd3_stream *stream, fgk_stream *h, int is_encode)
 {
   usize_t ui;
-  size_t si;
+  int si;
 
   h->root_node       = h->alphabet;
   h->decode_ptr      = h->root_node;
@@ -217,7 +217,7 @@ static int fgk_init (xd3_stream *stream, fgk_stream *h, int is_encode)
   /* Zero frequency nodes are inserted in the first alphabet_size
    * positions, with Value, weight, and a pointer to the next zero
    * frequency node.  */
-  for (si = h->alphabet_size - 1; si >= 0; si -= 1)
+  for (si = (int)(h->alphabet_size - 1U); si >= 0; si -= 1)
     {
       fgk_init_node (h->alphabet + si, (usize_t) si, h->alphabet_size);
     }
@@ -655,7 +655,7 @@ static void fgk_factor_remaining (fgk_stream *h)
       i >>= 1;
     }
 
-  i = 1 << h->zero_freq_exp;
+  i = 1U << h->zero_freq_exp;
 
   h->zero_freq_rem = h->zero_freq_count - i;
 }
diff --git a/xdelta3/xdelta3-hash.h b/xdelta3/xdelta3-hash.h
index e359436..cd579af 100644
--- a/xdelta3/xdelta3-hash.h
+++ b/xdelta3/xdelta3-hash.h
@@ -134,10 +134,10 @@ xd3_lcksum (const uint8_t *seg, const usize_t ln)
 
 #if XD3_ENCODER
 static usize_t
-xd3_size_log2 (usize_t slots)
+xd3_size_log2 (size_t slots)
 {
-  int bits = 28; /* This should not be an unreasonable limit. */
-  int i;
+  usize_t bits = 31;
+  usize_t i;
 
   for (i = 3; i <= bits; i += 1)
     {
@@ -155,13 +155,12 @@ xd3_size_log2 (usize_t slots)
 
 static void
 xd3_size_hashtable (xd3_stream    *stream,
-                    usize_t        slots,
+                    size_t         slots,
                     xd3_hash_cfg  *cfg)
 {
-  int bits = xd3_size_log2 (slots);
+  usize_t bits = xd3_size_log2 (slots);
 
-  /* TODO: there's a 32-bit assumption here */
-  cfg->size  = (1 << bits);
+  cfg->size  = (1U << bits);
   cfg->mask  = (cfg->size - 1);
   cfg->shift = 32 - bits;
 }
diff --git a/xdelta3/xdelta3-list.h b/xdelta3/xdelta3-list.h
index 6e3125f..9b3bc2b 100644
--- a/xdelta3/xdelta3-list.h
+++ b/xdelta3/xdelta3-list.h
@@ -111,11 +111,11 @@ LTYPE ## _next (ETYPE *f)                                               \
   return LTYPE ## _entry (f->LNAME.next);                               \
 }                                                                       \
                                                                         \
-static inline usize_t                                                   \
+static inline size_t                                                    \
 LTYPE ## _length (LTYPE *l)                                             \
 {                                                                       \
   LTYPE *p;                                                             \
-  int c = 0;                                                            \
+  size_t c = 0;                                                         \
                                                                         \
   for (p = l->next; p != l; p = p->next)                                \
     {                                                                   \
diff --git a/xdelta3/xdelta3-second.h b/xdelta3/xdelta3-second.h
index b9830ab..5fc93ed 100644
--- a/xdelta3/xdelta3-second.h
+++ b/xdelta3/xdelta3-second.h
@@ -33,7 +33,7 @@ static inline int xd3_decode_bits (xd3_stream     *stream,
                                    usize_t        *valuep)
 {
   usize_t value = 0;
-  usize_t vmask = 1 << nbits;
+  usize_t vmask = 1U << nbits;
 
   if (bits->cur_mask == 0x100) { goto next_byte; }
 
@@ -215,7 +215,7 @@ static inline int xd3_encode_bits (xd3_stream      *stream,
                                    usize_t           value)
 {
   int ret;
-  usize_t mask = 1 << nbits;
+  usize_t mask = 1U << nbits;
 
   XD3_ASSERT (nbits > 0);
   XD3_ASSERT (nbits < sizeof (usize_t) * 8);
diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index 2d6f926..319d8c1 100644
--- a/xdelta3/xdelta3.c
+++ b/xdelta3/xdelta3.c
@@ -533,7 +533,7 @@ static int xd3_srcwin_move_point (xd3_stream *stream,
 static int xd3_emit_run (xd3_stream *stream, usize_t pos,
                          usize_t size, uint8_t *run_c);
 static usize_t xd3_checksum_hash (const xd3_hash_cfg *cfg,
-                                  const usize_t cksum);
+                                 const usize_t cksum);
 static xoff_t xd3_source_cksum_offset(xd3_stream *stream, usize_t low);
 static void xd3_scksum_insert (xd3_stream *stream,
                                usize_t inx,
@@ -999,7 +999,7 @@ static void
 xd3_build_code_table (const xd3_code_table_desc *desc, xd3_dinst *tbl)
 {
   usize_t size1, size2, mode;
-  usize_t cpy_modes = 2 + desc->near_modes + desc->same_modes;
+  usize_t cpy_modes = 2U + desc->near_modes + desc->same_modes;
   xd3_dinst *d = tbl;
 
   (d++)->type1 = XD3_RUN;
@@ -1015,7 +1015,8 @@ xd3_build_code_table (const xd3_code_table_desc *desc, xd3_dinst *tbl)
     {
       (d++)->type1 = XD3_CPY + mode;
 
-      for (size1 = MIN_MATCH; size1 < MIN_MATCH + desc->cpy_sizes; size1 += 1, d += 1)
+      for (size1 = MIN_MATCH; size1 < MIN_MATCH + desc->cpy_sizes; 
+           size1 += 1, d += 1)
         {
           d->type1 = XD3_CPY + mode;
           d->size1 = size1;
@@ -1593,17 +1594,16 @@ xd3_round_blksize (usize_t sz, usize_t blksz)
 #define A32_DO8(buf,i)  A32_DO4(buf,i); A32_DO4(buf,i+4);
 #define A32_DO16(buf)   A32_DO8(buf,0); A32_DO8(buf,8);
 
-static unsigned long adler32 (unsigned long adler, const uint8_t *buf, 
-                              usize_t len)
+static uint32_t adler32 (uint32_t adler, const uint8_t *buf, size_t len)
 {
-    unsigned long s1 = adler & 0xffff;
-    unsigned long s2 = (adler >> 16) & 0xffff;
+    uint32_t s1 = adler & 0xffff;
+    uint32_t s2 = (adler >> 16) & 0xffff;
     int k;
 
     while (len > 0)
       {
-        k    = (len < A32_NMAX) ? len : A32_NMAX;
-        len -= k;
+        k    = (len < A32_NMAX) ? (int) len : A32_NMAX;
+        len -= (size_t) k;
 
         while (k >= 16)
           {
@@ -2669,7 +2669,7 @@ xd3_set_source (xd3_stream *stream,
     }
 
   src->shiftby = shiftby;
-  src->maskby = (1 << shiftby) - 1;
+  src->maskby = (1U << shiftby) - 1;
 
   if (xd3_check_pow2 (src->max_winsize, NULL) != 0)
     {
@@ -3697,7 +3697,7 @@ xd3_encode_init (xd3_stream *stream, int full_init)
       if (large_comp)
         {
           usize_t hash_values = (stream->src->max_winsize /
-                                stream->smatcher.large_step);
+                                 stream->smatcher.large_step);
 
           xd3_size_hashtable (stream,
                               hash_values,
@@ -4565,7 +4565,8 @@ xd3_forward_match(const uint8_t *s1c, const uint8_t *s2c, int n)
 {
   int i = 0;
 #if UNALIGNED_OK
-  int nint = n / sizeof(int);
+  const int isize = sizeof(int);
+  int nint = n / isize;
 
   if (nint >> 3)
     {
@@ -4584,7 +4585,7 @@ xd3_forward_match(const uint8_t *s1c, const uint8_t *s2c, int n)
              s1[i++] == s2[j++] &&
              s1[i++] == s2[j++]) { }
 
-      i = (i - 1) * sizeof(int);
+      i = (i - 1) * isize;
     }
 #endif
 
@@ -5094,9 +5095,9 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
     {
       xoff_t  blkno;
       xoff_t  blkbaseoffset;
-      usize_t blkrem;
-      size_t oldpos;  /* Using ssize_t because of a  */
-      size_t blkpos;  /* do { blkpos-- }
+      xoff_t blkrem;
+      ssize_t oldpos;  /* Using ssize_t because of a  */
+      ssize_t blkpos;  /* do { blkpos-- }
                           while (blkpos >= oldpos); */
       int ret;
       xd3_blksize_div (stream->srcwin_cksum_pos,
@@ -5126,7 +5127,7 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
 
       blkpos = xd3_bytes_on_srcblk (stream->src, blkno);
 
-      if (blkpos < (size_t) stream->smatcher.large_look)
+      if (blkpos < (ssize_t) stream->smatcher.large_look)
         {
           stream->srcwin_cksum_pos = (blkno + 1) * stream->src->blksize;
           IF_DEBUG1 (DP(RINT "[srcwin_move_point] continue (end-of-block)\n"));
diff --git a/xdelta3/xdelta3.h b/xdelta3/xdelta3.h
index ec971b9..661a7ed 100644
--- a/xdelta3/xdelta3.h
+++ b/xdelta3/xdelta3.h
@@ -126,6 +126,7 @@
 #include <windows.h>
 #ifdef _MSC_VER
 #define inline
+typedef signed long    ssize_t;
 #if _MSC_VER < 1600
 typedef unsigned char  uint8_t;
 typedef unsigned short uint16_t;
@@ -631,9 +632,9 @@ struct _xd3_smatcher
 /* hash table size & power-of-two hash function. */
 struct _xd3_hash_cfg
 {
-  usize_t           size;
-  usize_t           shift;
-  usize_t           mask;
+  usize_t            size;
+  usize_t            shift;
+  usize_t            mask;
 };
 
 /* the sprev list */
@@ -733,13 +734,13 @@ struct _xd3_source
                                         sets after getblk request */
 
   /* xd3 sets */
-  usize_t              srclen;        /* length of this source window */
+  usize_t             srclen;        /* length of this source window */
   xoff_t              srcbase;       /* offset of this source window
                                         in the source itself */
   int                 shiftby;       /* for power-of-two blocksizes */
-  int                 maskby;        /* for power-of-two blocksizes */
+  usize_t             maskby;        /* for power-of-two blocksizes */
   xoff_t              cpyoff_blocks; /* offset of dec_cpyoff in blocks */
-  usize_t             cpyoff_blkoff; /* offset of copy window in
+  xoff_t              cpyoff_blkoff; /* offset of copy window in
                                         blocks, remainder */
   xoff_t              getblkno;      /* request block number: xd3 sets
                                         current getblk request */
@@ -752,7 +753,7 @@ struct _xd3_source
                                         * source position to be read.
                                         * Otherwise, equal to
                                         * max_blkno. */
-  xoff_t             onlastblk;  /* Number of bytes on max_blkno */
+  xoff_t              onlastblk;  /* Number of bytes on max_blkno */
   int                 eof_known;  /* Set to true when the first
                                    * partial block is read. */
 };
@@ -1322,11 +1323,11 @@ void xd3_blksize_div (const xoff_t offset,
 
 static inline
 void xd3_blksize_add (xoff_t *blkno,
-                      usize_t *blkoff,
+                      xoff_t *blkoff,
                       const xd3_source *source,
                       const usize_t add)
 {
-  usize_t blkdiff;
+  xoff_t blkdiff;
 
   /* Does not check for overflow, checked in xdelta3-decode.h. */
   *blkoff += add;