1 files changed, 81 insertions, 273 deletions

diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index cf2d224..0f739f2 100644
--- a/xdelta3/xdelta3.c
+++ b/xdelta3/xdelta3.c
@@ -455,55 +455,6 @@ XD3_MAKELIST(xd3_rlist, xd3_rinst, link);
 #define IF_BUILD_DEFAULT(x)
 #endif
 
-IF_BUILD_SOFT(static const xd3_smatcher    __smatcher_soft;)
-IF_BUILD_FAST(static const xd3_smatcher    __smatcher_fast;)
-IF_BUILD_SLOW(static const xd3_smatcher    __smatcher_slow;)
-IF_BUILD_FASTER(static const xd3_smatcher    __smatcher_faster;)
-IF_BUILD_FASTEST(static const xd3_smatcher    __smatcher_fastest;)
-IF_BUILD_DEFAULT(static const xd3_smatcher    __smatcher_default;)
-
-#if XD3_DEBUG
-#define SMALL_HASH_DEBUG1(s,inp)                                  \
-  usize_t debug_hval = xd3_checksum_hash (& (s)->small_hash,       \
-         xd3_scksum ((inp), (s)->smatcher.small_look))
-#define SMALL_HASH_DEBUG2(s,inp)                                  \
-  XD3_ASSERT (debug_hval == xd3_checksum_hash (& (s)->small_hash, \
-         xd3_scksum ((inp), (s)->smatcher.small_look)))
-#else
-#define SMALL_HASH_DEBUG1(s,inp)
-#define SMALL_HASH_DEBUG2(s,inp)
-#endif /* XD3_DEBUG */
-
-/* Update the run-length state */
-#define NEXTRUN(c) do { if ((c) == run_c) { run_l += 1; } \
-  else { run_c = (c); run_l = 1; } } while (0)
-
-/* Update the checksum state. */
-#define OLD_LARGE_CKSUM 1
-#if OLD_LARGE_CKSUM
-#define LARGE_CKSUM_UPDATE(cksum,base,look)                              \
-  do {                                                                   \
-    uint32_t old_c = PERMUTE((base)[0]);                                    \
-    uint32_t new_c = PERMUTE((base)[(look)]);                               \
-    uint32_t low   = (((cksum) & 0xffff) - old_c + new_c) & 0xffff;         \
-    uint32_t high  = (((cksum) >> 16) - (old_c * (look)) + low) & 0xffff;   \
-    (cksum) = (high << 16) | low;                                        \
-  } while (0)
-#else
-#define LARGE_CKSUM_UPDATE(cksum,base,look)                              \
-  do { \
-    // linear congruential generators of different
-    // sizes and good lattice structure
-  } while (1)
-#endif
-
-/* Multiply and add hash function */
-#if ARITH_SMALL_CKSUM
-#define SMALL_CKSUM_UPDATE(cksum,base,look) (cksum) = ((*(unsigned long*)(base+1)) * 71143)
-#else
-#define SMALL_CKSUM_UPDATE LARGE_CKSUM_UPDATE
-#endif
-
 /* Consume N bytes of input, only used by the decoder. */
 #define DECODE_INPUT(n)             \
   do {                              \
@@ -571,6 +522,37 @@ static int         xd3_srcwin_setup (xd3_stream *stream);
 static usize_t     xd3_iopt_last_matched (xd3_stream *stream);
 static int         xd3_emit_uint32_t (xd3_stream *stream, xd3_output **output, uint32_t num);
 
+static usize_t xd3_smatch (xd3_stream *stream,
+                           usize_t base,
+                           usize_t scksum,
+                           usize_t *match_offset);
+static int xd3_string_match_init (xd3_stream *stream);
+static usize_t xd3_scksum (const uint8_t *seg, const int ln);
+static int xd3_comprun (const uint8_t *seg, int slook, uint8_t *run_cp);
+static int xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point);
+
+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);
+static xoff_t xd3_source_cksum_offset(xd3_stream *stream, usize_t low);
+static void xd3_scksum_insert (xd3_stream *stream,
+                               usize_t inx,
+                               usize_t scksum,
+                               usize_t pos);
+
+
+#if XD3_DEBUG
+static void xd3_verify_run_state (xd3_stream    *stream,
+                                  const uint8_t *inp,
+                                  int            x_run_l,
+                                  uint8_t        x_run_c);
+static void xd3_verify_large_state (xd3_stream *stream,
+                                    const uint8_t *inp,
+                                    uint32_t x_cksum);
+static void xd3_verify_small_state (xd3_stream    *stream,
+                                    const uint8_t *inp,
+                                    uint32_t          x_cksum);
+
+#endif /* XD3_DEBUG */
 #endif /* XD3_ENCODER */
 
 static int         xd3_decode_allocate (xd3_stream  *stream, usize_t       size,
@@ -734,6 +716,13 @@ static const xd3_sec_type djw_sec_type;
 
 /***********************************************************************/
 
+#include "xdelta3-hash.h"
+
+/* Process template passes - this includes xdelta3.c several times. */
+#define __XDELTA3_C_TEMPLATE_PASS__
+#include "xdelta3-cfgs.h"
+#undef __XDELTA3_C_TEMPLATE_PASS__
+
 /* Process the inline pass. */
 #define __XDELTA3_C_INLINE_PASS__
 #include "xdelta3.c"
@@ -774,11 +763,6 @@ static const xd3_sec_type djw_sec_type =
 };
 #endif
 
-/* Process template passes - this includes xdelta3.c several times. */
-#define __XDELTA3_C_TEMPLATE_PASS__
-#include "xdelta3-cfgs.h"
-#undef __XDELTA3_C_TEMPLATE_PASS__
-
 #if XD3_MAIN || PYTHON_MODULE || SWIG_MODULE || NOT_MAIN
 #include "xdelta3-main.h"
 #endif
@@ -859,13 +843,19 @@ struct _xd3_code_table_desc
   uint8_t same_modes;           /* Number of same copy modes (default 3) */
   uint8_t cpy_sizes;            /* Number of immediate-size single copies (default 15) */
 
-  uint8_t addcopy_add_max;      /* Maximum add size for an add-copy double instruction, all modes (default 4) */
-  uint8_t addcopy_near_cpy_max; /* Maximum cpy size for an add-copy double instruction, up through VCD_NEAR modes (default 6) */
-  uint8_t addcopy_same_cpy_max; /* Maximum cpy size for an add-copy double instruction, VCD_SAME modes (default 4) */
+  uint8_t addcopy_add_max;      /* Maximum add size for an add-copy double instruction,
+                                   all modes (default 4) */
+  uint8_t addcopy_near_cpy_max; /* Maximum cpy size for an add-copy double instruction,
+                                   up through VCD_NEAR modes (default 6) */
+  uint8_t addcopy_same_cpy_max; /* Maximum cpy size for an add-copy double instruction,
+                                   VCD_SAME modes (default 4) */
 
-  uint8_t copyadd_add_max;      /* Maximum add size for a copy-add double instruction, all modes (default 1) */
-  uint8_t copyadd_near_cpy_max; /* Maximum cpy size for a copy-add double instruction, up through VCD_NEAR modes (default 4) */
-  uint8_t copyadd_same_cpy_max; /* Maximum cpy size for a copy-add double instruction, VCD_SAME modes (default 4) */
+  uint8_t copyadd_add_max;      /* Maximum add size for a copy-add double instruction,
+                                   all modes (default 1) */
+  uint8_t copyadd_near_cpy_max; /* Maximum cpy size for a copy-add double instruction,
+                                   up through VCD_NEAR modes (default 4) */
+  uint8_t copyadd_same_cpy_max; /* Maximum cpy size for a copy-add double instruction,
+                                   VCD_SAME modes (default 4) */
 
   xd3_code_table_sizes addcopy_max_sizes[MAX_MODES];
   xd3_code_table_sizes copyadd_max_sizes[MAX_MODES];
@@ -940,8 +930,8 @@ static const xd3_code_table_desc __alternate_code_table_desc = {
 static void
 xd3_build_code_table (const xd3_code_table_desc *desc, xd3_dinst *tbl)
 {
-  int size1, size2, mode;
-  int cpy_modes = 2 + desc->near_modes + desc->same_modes;
+  usize_t size1, size2, mode;
+  usize_t cpy_modes = 2 + desc->near_modes + desc->same_modes;
   xd3_dinst *d = tbl;
 
   (d++)->type1 = XD3_RUN;
@@ -968,7 +958,7 @@ xd3_build_code_table (const xd3_code_table_desc *desc, xd3_dinst *tbl)
     {
       for (size1 = 1; size1 <= desc->addcopy_add_max; size1 += 1)
         {
-          int max = (mode < 2 + desc->near_modes) ?
+          usize_t max = (mode < 2U + desc->near_modes) ?
             desc->addcopy_near_cpy_max :
             desc->addcopy_same_cpy_max;
 
@@ -984,7 +974,7 @@ xd3_build_code_table (const xd3_code_table_desc *desc, xd3_dinst *tbl)
 
   for (mode = 0; mode < cpy_modes; mode += 1)
     {
-      int max = (mode < 2 + desc->near_modes) ?
+      usize_t max = (mode < 2U + desc->near_modes) ?
         desc->copyadd_near_cpy_max :
         desc->copyadd_same_cpy_max;
 
@@ -1371,7 +1361,8 @@ xd3_apply_table_string (xd3_stream *stream, const uint8_t *code_string)
   int modes = TOTAL_MODES (stream);
   xd3_dinst *code_table;
 
-  if ((code_table = stream->code_table_alloc = xd3_alloc (stream, sizeof (xd3_dinst), 256)) == NULL)
+  if ((code_table = stream->code_table_alloc =
+       (xd3_dinst*) xd3_alloc (stream, sizeof (xd3_dinst), 256)) == NULL)
     {
       return ENOMEM;
     }
@@ -1493,91 +1484,7 @@ xd3_apply_table_encoding (xd3_stream *in_stream, const uint8_t *data, usize_t si
   return ret;
 }
 
-/***********************************************************************
- Permute stuff
- ***********************************************************************/
-
-#if HASH_PERMUTE == 0
-#define PERMUTE(x) (x)
-#else
-#define PERMUTE(x) (__single_hash[(uint)x])
-
-static const uint16_t __single_hash[256] =
-{
-  /* Random numbers generated using SLIB's pseudo-random number generator.  This hashes
-   * the input alphabet. */
-  0xbcd1, 0xbb65, 0x42c2, 0xdffe, 0x9666, 0x431b, 0x8504, 0xeb46,
-  0x6379, 0xd460, 0xcf14, 0x53cf, 0xdb51, 0xdb08, 0x12c8, 0xf602,
-  0xe766, 0x2394, 0x250d, 0xdcbb, 0xa678, 0x02af, 0xa5c6, 0x7ea6,
-  0xb645, 0xcb4d, 0xc44b, 0xe5dc, 0x9fe6, 0x5b5c, 0x35f5, 0x701a,
-  0x220f, 0x6c38, 0x1a56, 0x4ca3, 0xffc6, 0xb152, 0x8d61, 0x7a58,
-  0x9025, 0x8b3d, 0xbf0f, 0x95a3, 0xe5f4, 0xc127, 0x3bed, 0x320b,
-  0xb7f3, 0x6054, 0x333c, 0xd383, 0x8154, 0x5242, 0x4e0d, 0x0a94,
-  0x7028, 0x8689, 0x3a22, 0x0980, 0x1847, 0xb0f1, 0x9b5c, 0x4176,
-  0xb858, 0xd542, 0x1f6c, 0x2497, 0x6a5a, 0x9fa9, 0x8c5a, 0x7743,
-  0xa8a9, 0x9a02, 0x4918, 0x438c, 0xc388, 0x9e2b, 0x4cad, 0x01b6,
-  0xab19, 0xf777, 0x365f, 0x1eb2, 0x091e, 0x7bf8, 0x7a8e, 0x5227,
-  0xeab1, 0x2074, 0x4523, 0xe781, 0x01a3, 0x163d, 0x3b2e, 0x287d,
-  0x5e7f, 0xa063, 0xb134, 0x8fae, 0x5e8e, 0xb7b7, 0x4548, 0x1f5a,
-  0xfa56, 0x7a24, 0x900f, 0x42dc, 0xcc69, 0x02a0, 0x0b22, 0xdb31,
-  0x71fe, 0x0c7d, 0x1732, 0x1159, 0xcb09, 0xe1d2, 0x1351, 0x52e9,
-  0xf536, 0x5a4f, 0xc316, 0x6bf9, 0x8994, 0xb774, 0x5f3e, 0xf6d6,
-  0x3a61, 0xf82c, 0xcc22, 0x9d06, 0x299c, 0x09e5, 0x1eec, 0x514f,
-  0x8d53, 0xa650, 0x5c6e, 0xc577, 0x7958, 0x71ac, 0x8916, 0x9b4f,
-  0x2c09, 0x5211, 0xf6d8, 0xcaaa, 0xf7ef, 0x287f, 0x7a94, 0xab49,
-  0xfa2c, 0x7222, 0xe457, 0xd71a, 0x00c3, 0x1a76, 0xe98c, 0xc037,
-  0x8208, 0x5c2d, 0xdfda, 0xe5f5, 0x0b45, 0x15ce, 0x8a7e, 0xfcad,
-  0xaa2d, 0x4b5c, 0xd42e, 0xb251, 0x907e, 0x9a47, 0xc9a6, 0xd93f,
-  0x085e, 0x35ce, 0xa153, 0x7e7b, 0x9f0b, 0x25aa, 0x5d9f, 0xc04d,
-  0x8a0e, 0x2875, 0x4a1c, 0x295f, 0x1393, 0xf760, 0x9178, 0x0f5b,
-  0xfa7d, 0x83b4, 0x2082, 0x721d, 0x6462, 0x0368, 0x67e2, 0x8624,
-  0x194d, 0x22f6, 0x78fb, 0x6791, 0xb238, 0xb332, 0x7276, 0xf272,
-  0x47ec, 0x4504, 0xa961, 0x9fc8, 0x3fdc, 0xb413, 0x007a, 0x0806,
-  0x7458, 0x95c6, 0xccaa, 0x18d6, 0xe2ae, 0x1b06, 0xf3f6, 0x5050,
-  0xc8e8, 0xf4ac, 0xc04c, 0xf41c, 0x992f, 0xae44, 0x5f1b, 0x1113,
-  0x1738, 0xd9a8, 0x19ea, 0x2d33, 0x9698, 0x2fe9, 0x323f, 0xcde2,
-  0x6d71, 0xe37d, 0xb697, 0x2c4f, 0x4373, 0x9102, 0x075d, 0x8e25,
-  0x1672, 0xec28, 0x6acb, 0x86cc, 0x186e, 0x9414, 0xd674, 0xd1a5
-};
-#endif
-
-/***********************************************************************
- Ctable stuff
- ***********************************************************************/
-
-#if HASH_PRIME
-static const usize_t __primes[] =
-{
-  11, 19, 37, 73, 109,
-  163, 251, 367, 557, 823,
-  1237, 1861, 2777, 4177, 6247,
-  9371, 14057, 21089, 31627, 47431,
-  71143, 106721, 160073, 240101, 360163,
-  540217, 810343, 1215497, 1823231, 2734867,
-  4102283, 6153409, 9230113, 13845163, 20767711,
-  31151543, 46727321, 70090921, 105136301, 157704401,
-  236556601, 354834919, 532252367, 798378509, 1197567719,
-  1796351503
-};
-
-static const usize_t __nprimes = SIZEOF_ARRAY (__primes);
-#endif
-
-static inline uint32_t
-xd3_checksum_hash (const xd3_hash_cfg *cfg, const uint32_t cksum)
-{
-#if HASH_PRIME
-  /* If the table is prime compute the modulus. */
-  return (cksum % cfg->size);
-#else
-  /* If the table is power-of-two compute the mask.*/
-  return (cksum ^ (cksum >> cfg->shift)) & cfg->mask;
-#endif
-}
-
-/***********************************************************************
- Create the hash table.
- ***********************************************************************/
+/***********************************************************************/
 
 static inline void
 xd3_swap_uint8p (uint8_t** p1, uint8_t** p2)
@@ -1621,11 +1528,9 @@ xd3_check_pow2 (usize_t value, usize_t *logof)
 static usize_t
 xd3_pow2_roundup (usize_t x)
 {
-  int i = 1;
-  int s = 0;
+  usize_t i = 1;
   while (x > i) {
     i <<= 1;
-    s++;
   }
   return i;
 }
@@ -1640,106 +1545,6 @@ xd3_round_blksize (usize_t sz, usize_t blksz)
   return mod ? (sz + (blksz - mod)) : sz;
 }
 
-#if XD3_ENCODER
-#if !HASH_PRIME
-static usize_t
-xd3_size_log2 (usize_t slots)
-{
-  int bits = 28; /* This should not be an unreasonable limit. */
-  int i;
-
-  for (i = 3; i <= bits; i += 1)
-    {
-      if (slots < (1 << i))
-        {
-          bits = i-1;
-          break;
-        }
-    }
-
-  return bits;
-}
-#endif
-
-static void
-xd3_size_hashtable (xd3_stream    *stream,
-                    usize_t        slots,
-                    xd3_hash_cfg  *cfg)
-{
-  /* initialize ctable: the number of hash buckets is computed from the table of primes or
-   * the nearest power-of-two, in both cases rounding down in favor of using less
-   * memory. */
-
-#if HASH_PRIME
-  usize_t i;
-
-  cfg->size = __primes[__nprimes-1];
-
-  for (i = 1; i < __nprimes; i += 1)
-    {
-      if (slots < __primes[i])
-        {
-          cfg->size = __primes[i-1];
-          break;
-        }
-    }
-#else
-  int bits = xd3_size_log2 (slots);
-
-  cfg->size  = (1 << bits);
-  cfg->mask  = (cfg->size - 1);
-  cfg->shift = min (32 - bits, 16);
-#endif
-}
-#endif
-
-/***********************************************************************
- Cksum function
- ***********************************************************************/
-
-#if OLD_LARGE_CKSUM
-static inline uint32_t
-xd3_lcksum (const uint8_t *seg, const int ln)
-{
-  int i = 0;
-  uint32_t low  = 0;
-  uint32_t high = 0;
-
-  for (; i < ln; i += 1)
-    {
-      low  += PERMUTE(*seg++);
-      high += low;
-    }
-
-  return ((high & 0xffff) << 16) | (low & 0xffff);
-}
-#else
-static inline int
-xd3_lcksum (const uint8_t *seg, const int ln)
-{
-  int i;
-  int x = 0;
-  for (i = 0; i < ln; ++i)
-    {
-      x = (x * 103) + *seg++;
-    }
-  return x;
-}
-#endif
-
-#if ARITH_SMALL_CKSUM
-static inline usize_t
-xd3_scksum (const uint8_t *seg, const int ln)
-{
-  usize_t c;
-  /* The -1 is because UPDATE operates on seg[1..ln] */
-  SMALL_CKSUM_UPDATE (c,(seg-1),ln);
-  return c;
-}
-#else
-#define xd3_scksum(seg,ln) xd3_lcksum(seg,ln)
-#endif
-
 /***********************************************************************
  Adler32 stream function: code copied from Zlib, defined in RFC1950
  ***********************************************************************/
@@ -1792,7 +1597,7 @@ static unsigned long adler32 (unsigned long adler, const uint8_t *buf, usize_t l
  Run-length function
  ***********************************************************************/
 
-static inline int
+static int
 xd3_comprun (const uint8_t *seg, int slook, uint8_t *run_cp)
 {
   int i;
@@ -2076,10 +1881,10 @@ static int
 xd3_alloc_cache (xd3_stream *stream)
 {
   if (((stream->acache.s_near > 0) &&
-       (stream->acache.near_array =
+       (stream->acache.near_array = (usize_t*)
         xd3_alloc (stream, stream->acache.s_near, sizeof (usize_t))) == NULL) ||
       ((stream->acache.s_same > 0) &&
-       (stream->acache.same_array =
+       (stream->acache.same_array = (usize_t*)
         xd3_alloc (stream, stream->acache.s_same * 256, sizeof (usize_t))) == NULL))
     {
       return ENOMEM;
@@ -2124,7 +1929,7 @@ static int
 xd3_encode_address (xd3_stream *stream, usize_t addr, usize_t here, uint8_t* mode)
 {
   usize_t d, bestd;
-  int   i, bestm, ret;
+  usize_t i, bestm, ret;
   xd3_addr_cache* acache = & stream->acache;
 
 #define SMALLEST_INT(x) do { if (((x) & ~127) == 0) { goto good; } } while (0)
@@ -2300,12 +2105,12 @@ xd3_alloc_output (xd3_stream *stream,
     }
   else
     {
-      if ((output = xd3_alloc (stream, 1, sizeof (xd3_output))) == NULL)
+      if ((output = (xd3_output*) xd3_alloc (stream, 1, sizeof (xd3_output))) == NULL)
         {
           return NULL;
         }
 
-      if ((base = xd3_alloc (stream, XD3_ALLOCSIZE, sizeof (uint8_t))) == NULL)
+      if ((base = (uint8_t*) xd3_alloc (stream, XD3_ALLOCSIZE, sizeof (uint8_t))) == NULL)
         {
           xd3_free (stream, output);
           return NULL;
@@ -3395,7 +3200,7 @@ xd3_emit_double (xd3_stream *stream, xd3_rinst *first, xd3_rinst *second, uint c
 
 /* This enters a potential run instruction into the iopt buffer.  The position argument is
  * relative to the target window. */
-static inline int
+static int
 xd3_emit_run (xd3_stream *stream, usize_t pos, usize_t size, uint8_t run_c)
 {
   xd3_rinst* ri;
@@ -3604,7 +3409,8 @@ xd3_encode_buffer_leftover (xd3_stream *stream)
   usize_t room;
 
   /* Allocate the buffer. */
-  if (stream->buf_in == NULL && (stream->buf_in = xd3_alloc (stream, stream->winsize, 1)) == NULL)
+  if (stream->buf_in == NULL &&
+      (stream->buf_in = (uint8_t*) xd3_alloc (stream, stream->winsize, 1)) == NULL)
     {
       return ENOMEM;
     }
@@ -3659,10 +3465,11 @@ static int
 xd3_alloc_iopt (xd3_stream *stream, int elts)
 {
   int i;
-  xd3_iopt_buflist* last = xd3_alloc (stream, sizeof (xd3_iopt_buflist), 1);
+  xd3_iopt_buflist* last =
+    (xd3_iopt_buflist*) xd3_alloc (stream, sizeof (xd3_iopt_buflist), 1);
 
   if (last == NULL ||
-      (last->buffer = xd3_alloc (stream, sizeof (xd3_rinst), elts)) == NULL)
+      (last->buffer = (xd3_rinst*) xd3_alloc (stream, sizeof (xd3_rinst), elts)) == NULL)
     {
       return ENOMEM;
     }
@@ -4238,7 +4045,8 @@ xd3_string_match_init (xd3_stream *stream)
 
   if (DO_LARGE && stream->large_table == NULL)
     {
-      if ((stream->large_table = xd3_alloc0 (stream, stream->large_hash.size, sizeof (usize_t))) == NULL)
+      if ((stream->large_table =
+           (usize_t*) xd3_alloc0 (stream, stream->large_hash.size, sizeof (usize_t))) == NULL)
         {
           return ENOMEM;
         }
@@ -4262,9 +4070,9 @@ xd3_string_match_init (xd3_stream *stream)
           return 0;
         }
 
-      if ((stream->small_table = xd3_alloc0 (stream,
-                                             stream->small_hash.size,
-                                             sizeof (usize_t))) == NULL)
+      if ((stream->small_table = (usize_t*) xd3_alloc0 (stream,
+                                                        stream->small_hash.size,
+                                                        sizeof (usize_t))) == NULL)
         {
           return ENOMEM;
         }
@@ -4273,9 +4081,9 @@ xd3_string_match_init (xd3_stream *stream)
       if (stream->smatcher.small_lchain > 1 ||
           stream->smatcher.small_chain > 1)
         {
-          if ((stream->small_prev = xd3_alloc (stream,
-                                               stream->sprevsz,
-                                               sizeof (xd3_slist))) == NULL)
+          if ((stream->small_prev = (xd3_slist*) xd3_alloc (stream,
+                                                            stream->sprevsz,
+                                                            sizeof (xd3_slist))) == NULL)
             {
               return ENOMEM;
             }
@@ -4530,7 +4338,7 @@ static inline usize_t
 xd3_forward_match(const uint8_t *s1c,
                   const uint8_t *s2c,
                   usize_t n) {
-  int i = 0;
+  usize_t i = 0;
   while (i < n && s1c[i] == s2c[i])
     {
       i++;
@@ -5020,7 +4828,7 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
       oldpos = blkrem;
       blkpos = xd3_bytes_on_srcblk_fast (stream->src, blkno);
 
-      if (oldpos + stream->smatcher.large_look > blkpos)
+      if (oldpos + stream->smatcher.large_look > (usize_t) blkpos)
         {
           stream->srcwin_cksum_pos = (blkno + 1) * stream->src->blksize;
           continue;
@@ -5130,7 +4938,7 @@ XD3_TEMPLATE(xd3_string_match_) (xd3_stream *stream)
   usize_t         sinx;
   usize_t         linx;
   uint8_t        run_c;
-  int            run_l;
+  size_t          run_l;
   int            ret;
   usize_t         match_length;
   usize_t         match_offset = 0;