Compile with g++ 3.4.4 and add C++ checksum_test.cc

10 files changed, 482 insertions, 345 deletions

diff --git a/xdelta3/Makefile b/xdelta3/Makefile
index 9c8b79e..a4c7281 100644
--- a/xdelta3/Makefile
+++ b/xdelta3/Makefile
@@ -5,6 +5,7 @@ SOURCES = xdelta3-cfgs.h \
           xdelta3-decode.h \
           xdelta3-djw.h \
           xdelta3-fgk.h \
+          xdelta3-hash.h \
           xdelta3-list.h \
           xdelta3-main.h \
           xdelta3-python.h \
@@ -49,6 +50,7 @@ EXTRA = Makefile COPYING linkxd3lib.c badcopy.c xdelta3.swig \
         examples/Makefile examples/small_page_test.c \
         examples/README examples/encode_decode_test.c \
         examples/compare_test.c examples/speed_test.c \
+        examples/test.h examples/checksum_test.c \
         xdelta3.py xdelta3_wrap.c xdelta3.wxs xdelta3.wxi \
         README readme.txt
 
diff --git a/xdelta3/examples/Makefile b/xdelta3/examples/Makefile
index 0e1825d..abdb6be 100755
--- a/xdelta3/examples/Makefile
+++ b/xdelta3/examples/Makefile
@@ -4,9 +4,9 @@ CFLAGS = -O3 -Wall -I.. -DXD3_DEBUG=0 -fno-builtin
 
 SOURCES = small_page_test.c encode_decode_test.c speed_test.c
 
-DEPS = ../*.h ../*.c
+DEPS = ../*.h ../*.c *.h
 
-TARGETS = small_page_test encode_decode_test speed_test32 speed_test64 compare_test
+TARGETS = small_page_test encode_decode_test speed_test32 speed_test64 compare_test checksum_test
 
 all: $(TARGETS)
 
@@ -25,5 +25,8 @@ speed_test64: speed_test.c $(DEPS)
 compare_test: compare_test.c
         $(CC) $(CFLAGS) compare_test.c -o compare_test
 
+checksum_test: checksum_test.cc
+        $(CXX) $(CFLAGS) checksum_test.cc -o checksum_test
+
 clean:
         rm -f *.exe *.stackdump $(TARGETS)
diff --git a/xdelta3/examples/checksum_test.cc b/xdelta3/examples/checksum_test.cc
new file mode 100644
index 0000000..821291a
--- /dev/null
+++ b/xdelta3/examples/checksum_test.cc
@@ -0,0 +1,79 @@
+/* Copyright (C) 2007 Josh MacDonald */
+
+extern "C" {
+#include "test.h"
+#include <assert.h>
+}
+
+// template <typename T, int Cklen>
+// struct cksum_params {
+//   typedef T cksum_type;
+//   enum { cklen = Cklen };
+// };
+
+template <int Cklen>
+struct rabin_karp {
+  enum { cklen = Cklen, };
+};
+
+template<typename T>
+struct test_result {
+
+  int n_data;
+
+  test_result()
+    : n_data(0) {
+  }
+
+  void print() {
+    fprintf(stderr, "cklen %u: %u results\n", T::cklen, n_data);
+  }
+
+  void add(uint8_t* ptr) {
+    n_data++;
+  }
+};
+
+typedef rabin_karp<4> small_cksum;
+typedef rabin_karp<9> large_cksum;
+
+template<typename T>
+void test(uint8_t* buf, usize_t buf_len) {
+  test_result<T> result;
+
+  for (usize_t i = 0; i < buf_len - T::cklen; i++) {
+    result.add(buf + i);
+  }
+
+  result.print();
+}
+
+int main(int argc, char** argv) {
+  int i;
+  uint8_t *buf = NULL;
+  usize_t buf_len = 0;
+  int ret;
+
+  if (argc <= 1) {
+    fprintf(stderr, "usage: %s file ...", argv[0]);
+    return 1;
+  }
+
+  for (i = 1; i < argc; i++) {
+    if ((ret = read_whole_file(argv[i],
+                               & buf,
+                               & buf_len))) {
+      return 1;
+    }
+
+    fprintf(stderr, "file %s is %u bytes\n", argv[i], buf_len);
+
+    test<small_cksum>(buf, buf_len);
+    test<large_cksum>(buf, buf_len);
+
+    free(buf);
+    buf = NULL;
+  }
+
+  return 0;      
+}
diff --git a/xdelta3/examples/speed_test.c b/xdelta3/examples/speed_test.c
index dea6621..532be17 100644
--- a/xdelta3/examples/speed_test.c
+++ b/xdelta3/examples/speed_test.c
@@ -1,9 +1,6 @@
 /* Copyright (C) 2007 Josh MacDonald */
 
-#define NOT_MAIN 1
-
-#include "xdelta3.h"
-#include "xdelta3.c"
+#include "test.h"
 
 usize_t bench_speed(const uint8_t *from_buf, const size_t from_len,
                  const uint8_t *to_buf, const size_t to_len,
@@ -19,39 +16,6 @@ usize_t bench_speed(const uint8_t *from_buf, const size_t from_len,
   return delta_size;
 }
 
-int read_whole_file(const char *name,
-                    uint8_t **buf_ptr,
-                    size_t *buf_len) {
-  main_file file;
-  int ret;
-  xoff_t len;
-  size_t nread;
-  main_file_init(&file);
-  file.filename = name;
-  ret = main_file_open(&file, name, XO_READ);
-  if (ret != 0) {
-    goto exit;
-  }
-  ret = main_file_stat(&file, &len, 1);
-  if (ret != 0) {
-    goto exit;
-  }
-  
-  (*buf_len) = (size_t)len;
-  (*buf_ptr) = main_malloc(*buf_len);
-  ret = main_file_read(&file, *buf_ptr, *buf_len, &nread,
-                       "read failed");
-  if (ret == 0 && *buf_len == nread) {
-    ret = 0;
-  } else {
-    fprintf(stderr, "invalid read\n");
-    ret = XD3_INTERNAL;
-  }
- exit:
-  main_file_cleanup(&file);
-  return ret;
-}
-
 int main(int argc, char **argv) {
   int repeat, level;
   char *from, *to;
diff --git a/xdelta3/examples/test.h b/xdelta3/examples/test.h
new file mode 100644
index 0000000..f6dd7e5
--- /dev/null
+++ b/xdelta3/examples/test.h
@@ -0,0 +1,40 @@
+/* Copyright (C) 2007 Josh MacDonald */
+
+#define NOT_MAIN 1
+
+#include "xdelta3.h"
+#include "xdelta3.c"
+
+static int read_whole_file(const char *name,
+                           uint8_t **buf_ptr,
+                           size_t *buf_len) {
+  main_file file;
+  int ret;
+  xoff_t len;
+  size_t nread;
+  main_file_init(&file);
+  file.filename = name;
+  ret = main_file_open(&file, name, XO_READ);
+  if (ret != 0) {
+    goto exit;
+  }
+  ret = main_file_stat(&file, &len, 1);
+  if (ret != 0) {
+    goto exit;
+  }
+  
+  (*buf_len) = (size_t)len;
+  (*buf_ptr) = (uint8_t*) main_malloc(*buf_len);
+  ret = main_file_read(&file, *buf_ptr, *buf_len, &nread,
+                       "read failed");
+  if (ret == 0 && *buf_len == nread) {
+    ret = 0;
+  } else {
+    fprintf(stderr, "invalid read\n");
+    ret = XD3_INTERNAL;
+  }
+ exit:
+  main_file_cleanup(&file);
+  return ret;
+}
+
diff --git a/xdelta3/xdelta3-cfgs.h b/xdelta3/xdelta3-cfgs.h
index 39fca3b..b13f7b0 100644
--- a/xdelta3/xdelta3-cfgs.h
+++ b/xdelta3/xdelta3-cfgs.h
@@ -54,7 +54,7 @@
 #define TEMPLATE      fastest
 #define LLOOK         9
 #define LSTEP         26
-#define SLOOK         4
+#define SLOOK         4U
 #define SCHAIN        1
 #define SLCHAIN       1
 #define MAXLAZY       6
@@ -79,7 +79,7 @@
 #define TEMPLATE      faster
 #define LLOOK         9
 #define LSTEP         15
-#define SLOOK         4
+#define SLOOK         4U
 #define SCHAIN        1
 #define SLCHAIN       1
 #define MAXLAZY       18
@@ -104,7 +104,7 @@
 #define TEMPLATE      fast
 #define LLOOK         9
 #define LSTEP         8
-#define SLOOK         4
+#define SLOOK         4U
 #define SCHAIN        4
 #define SLCHAIN       1
 #define MAXLAZY       18
@@ -129,7 +129,7 @@
 #define TEMPLATE      slow
 #define LLOOK         9
 #define LSTEP         2
-#define SLOOK         4
+#define SLOOK         4U
 #define SCHAIN        44
 #define SLCHAIN       13
 #define MAXLAZY       90
@@ -154,7 +154,7 @@
 #define TEMPLATE      default
 #define LLOOK         9
 #define LSTEP         3
-#define SLOOK         4
+#define SLOOK         4U
 #define SCHAIN        8
 #define SLCHAIN       2
 #define MAXLAZY       36
diff --git a/xdelta3/xdelta3-decode.h b/xdelta3/xdelta3-decode.h
index 0b49fb9..8e3e799 100644
--- a/xdelta3/xdelta3-decode.h
+++ b/xdelta3/xdelta3-decode.h
@@ -85,7 +85,7 @@ xd3_decode_setup_buffers (xd3_stream *stream)
 
       stream->space_out = xd3_round_blksize (stream->dec_tgtlen, XD3_ALLOCSIZE);
 
-      if ((stream->dec_buffer = xd3_alloc (stream, stream->space_out, 1)) == NULL)
+      if ((stream->dec_buffer = (uint8_t*) xd3_alloc (stream, stream->space_out, 1)) == NULL)
         {
           return ENOMEM;
         }
@@ -118,7 +118,7 @@ xd3_decode_allocate (xd3_stream  *stream,
     {
       *buf_alloc = xd3_round_blksize (size, XD3_ALLOCSIZE);
 
-      if ((*buf_ptr = xd3_alloc (stream, *buf_alloc, 1)) == NULL)
+      if ((*buf_ptr = (uint8_t*) xd3_alloc (stream, *buf_alloc, 1)) == NULL)
         {
           return ENOMEM;
         }
@@ -805,7 +805,8 @@ xd3_decode_input (xd3_stream *stream)
         {
           /* Get the code table data. */
           if ((stream->dec_codetbl == NULL) &&
-              (stream->dec_codetbl = xd3_alloc (stream, stream->dec_codetblsz, 1)) == NULL) { return ENOMEM; }
+              (stream->dec_codetbl =
+               (uint8_t*) xd3_alloc (stream, stream->dec_codetblsz, 1)) == NULL) { return ENOMEM; }
 
           if ((ret = xd3_decode_bytes (stream, stream->dec_codetbl, & stream->dec_codetblbytes, stream->dec_codetblsz)))
             {
@@ -840,7 +841,8 @@ xd3_decode_input (xd3_stream *stream)
           /* Note: we add an additional byte for padding, to allow
              0-termination. */
           if ((stream->dec_appheader == NULL) &&
-              (stream->dec_appheader = xd3_alloc (stream, stream->dec_appheadsz+1, 1)) == NULL) { return ENOMEM; }
+              (stream->dec_appheader =
+               (uint8_t*) xd3_alloc (stream, stream->dec_appheadsz+1, 1)) == NULL) { return ENOMEM; }
 
           stream->dec_appheader[stream->dec_appheadsz] = 0;
 
diff --git a/xdelta3/xdelta3-hash.h b/xdelta3/xdelta3-hash.h
new file mode 100644
index 0000000..a1cc9d8
--- /dev/null
+++ b/xdelta3/xdelta3-hash.h
@@ -0,0 +1,237 @@
+/* xdelta 3 - delta compression tools and library
+ * Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007.  Joshua P. MacDonald
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/* To know more about Xdelta, start by reading xdelta3.c.  If you are
+ * ready to use the API, continue reading here.  There are two
+ * interfaces -- xd3_encode_input and xd3_decode_input -- plus a dozen
+ * or so related calls.  This interface is styled after Zlib. */
+
+#ifndef _XDELTA3_HASH_H_
+#define _XDELTA3_HASH_H_
+
+#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
+
+/***********************************************************************
+ 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 usize_t
+xd3_checksum_hash (const xd3_hash_cfg *cfg, const usize_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
+}
+
+/***********************************************************************
+ Cksum function
+ ***********************************************************************/
+
+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);
+}
+
+#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
+
+#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 < (1U << i))
+        {
+          bits = i-1;
+          break;
+        }
+    }
+
+  return bits;
+}
+#endif
+#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
diff --git a/xdelta3/xdelta3-main.h b/xdelta3/xdelta3-main.h
index 23133a3..5c02a75 100644
--- a/xdelta3/xdelta3-main.h
+++ b/xdelta3/xdelta3-main.h
@@ -227,7 +227,7 @@ struct _main_extcomp
 
   const char    *ident;
   const char    *magic;
-  int            magic_size;
+  usize_t        magic_size;
   int            flags;
 };
 
@@ -300,7 +300,7 @@ static uint8_t*       appheader_used = NULL;
 static uint8_t*       main_bdata = NULL;
 
 /* The LRU: obviously this is shared by all callers. */
-static int               lru_size = 0;
+static usize_t           lru_size = 0;
 static main_blklru      *lru = NULL;  /* array of lru_size elts */
 static main_blklru_list  lru_list;
 static main_blklru_list  lru_free;
@@ -550,7 +550,7 @@ static char*
 main_format_bcnt (xoff_t r, char *buf)
 {
   static const char* fmts[] = { "B", "KB", "MB", "GB" };
-  int i;
+  usize_t i;
 
   for (i = 0; i < SIZEOF_ARRAY(fmts); i += 1)
     {
@@ -977,7 +977,7 @@ main_file_seek (main_file *xfile, xoff_t pos)
   if (fseek (xfile->file, pos, SEEK_SET) != 0) { ret = get_errno (); }
 
 #elif XD3_POSIX
-  if (lseek (xfile->file, pos, SEEK_SET) != pos) { ret = get_errno (); }
+  if ((xoff_t) lseek (xfile->file, pos, SEEK_SET) != pos) { ret = get_errno (); }
 
 #elif XD3_WIN32
   LARGE_INTEGER move, out;
@@ -1725,10 +1725,10 @@ main_decompress_input_check (main_file   *ifile,
                             usize_t      input_size,
                             usize_t     *nread)
 {
-  int i;
   int ret;
+  usize_t i;
+  usize_t check_nread;
   uint8_t check_buf[XD3_ALLOCSIZE];
-  usize_t  check_nread;
 
   if ((ret = main_file_read (ifile, check_buf, min (input_size, XD3_ALLOCSIZE), & check_nread, "input read failed")))
     {
@@ -1794,7 +1794,8 @@ main_decompress_source (main_file *sfile, xd3_source *source)
 
   /* Make a template for mkstmp() */
   if (tmpdir == NULL) { tmpdir = "/tmp"; }
-  if ((tmpname = main_malloc (strlen (tmpdir) + sizeof (tmpl) + 1)) == NULL) { return ENOMEM; }
+  if ((tmpname =
+       (char*) main_malloc (strlen (tmpdir) + sizeof (tmpl) + 1)) == NULL) { return ENOMEM; }
   sprintf (tmpname, "%s%s", tmpdir, tmpl);
 
   XD3_ASSERT (ext_tmpfile == NULL);
@@ -1960,7 +1961,7 @@ main_recompress_output (main_file *ofile)
 static const main_extcomp*
 main_ident_compressor (const char *ident)
 {
-  int i;
+  usize_t i;
 
   for (i = 0; i < SIZEOF_ARRAY (extcomp_types); i += 1)
     {
@@ -2059,7 +2060,7 @@ main_set_appheader (xd3_stream *stream, main_file *input, main_file *sfile)
           sname = scomp = "";
         }
 
-      if ((appheader_used = main_malloc (len)) == NULL)
+      if ((appheader_used = (uint8_t*) main_malloc (len)) == NULL)
         {
           return ENOMEM;
         }
@@ -2103,7 +2104,7 @@ main_get_appheader_params (main_file *file, char **parsed, int output, const cha
           int dlen = last_slash - other->filename;
 
           XD3_ASSERT(file->filename_copy == NULL);
-          file->filename_copy = main_malloc(dlen + 2 + strlen(file->filename));
+          file->filename_copy = (char*) main_malloc(dlen + 2 + strlen(file->filename));
 
           strncpy(file->filename_copy, other->filename, dlen);
           file->filename_copy[dlen] = '/';
@@ -2264,7 +2265,8 @@ main_open_output (xd3_stream *stream, main_file *ofile)
 static int
 main_set_source (xd3_stream *stream, int cmd, main_file *sfile, xd3_source *source)
 {
-  int ret = 0, i;
+  int ret = 0;
+  usize_t i;
   uint8_t *tmp_buf = NULL;
 
   /* Open it, check for seekability, set required xd3_source fields. */
@@ -2296,7 +2298,7 @@ main_set_source (xd3_stream *stream, int cmd, main_file *sfile, xd3_source *sour
       if (IS_ENCODE (cmd))
         {
           usize_t nread;
-          tmp_buf = main_malloc(XD3_ALLOCSIZE);
+          tmp_buf = (uint8_t*) main_malloc (XD3_ALLOCSIZE);
 
           if ((ret = main_file_read (sfile, tmp_buf, XD3_ALLOCSIZE,
                                      & nread, "source read failed")))
@@ -2386,7 +2388,7 @@ main_set_source (xd3_stream *stream, int cmd, main_file *sfile, xd3_source *sour
       XPR(NT "source block size: %u\n", source->blksize);
     }
 
-  if ((lru = main_malloc (sizeof (main_blklru) * lru_size)) == NULL)
+  if ((lru = (main_blklru*) main_malloc (sizeof (main_blklru) * lru_size)) == NULL)
     {
       ret = ENOMEM;
       goto error;
@@ -2396,7 +2398,7 @@ main_set_source (xd3_stream *stream, int cmd, main_file *sfile, xd3_source *sour
     {
       lru[i].blkno = (xoff_t) -1;
 
-      if ((lru[i].blk = main_malloc (source->blksize)) == NULL)
+      if ((lru[i].blk = (uint8_t*) main_malloc (source->blksize)) == NULL)
         {
           ret = ENOMEM;
           goto error;
@@ -2454,13 +2456,13 @@ main_getblk_func (xd3_stream *stream,
                   xd3_source *source,
                   xoff_t      blkno)
 {
-  xoff_t      pos   = blkno * source->blksize;
-  main_file   *sfile = (main_file*) source->ioh;
+  int ret;
+  xoff_t pos = blkno * source->blksize;
+  main_file *sfile = (main_file*) source->ioh;
   main_blklru *blru  = NULL;
-  usize_t      onblk = xd3_bytes_on_srcblk_fast (source, blkno);
-  usize_t      nread;
-  int         ret;
-  int         i;
+  usize_t onblk = xd3_bytes_on_srcblk_fast (source, blkno);
+  usize_t nread;
+  usize_t i;
 
   if (allow_fake_source)
     {
@@ -2728,7 +2730,7 @@ main_input (xd3_cmd     cmd,
 
   main_set_winsize (ifile);
 
-  if ((main_bdata = main_malloc (option_winsize)) == NULL)
+  if ((main_bdata = (uint8_t*) main_malloc (option_winsize)) == NULL)
     {
       return EXIT_FAILURE;
     }
@@ -3048,7 +3050,7 @@ done:
 static void
 main_cleanup (void)
 {
-  int i;
+  usize_t i;
 
   if (appheader_used != NULL &&
       appheader_used != option_appheader)
@@ -3105,7 +3107,7 @@ setup_environment (int argc,
     return;
   }
 
-  (*env_free) = main_malloc(strlen(v) + 1);
+  (*env_free) = (char*) main_malloc(strlen(v) + 1);
   strcpy(*env_free, v);
 
   /* Space needed for extra args, at least # of spaces */
@@ -3116,7 +3118,7 @@ setup_environment (int argc,
     }
   }
 
-  (*argv_free) = main_malloc(sizeof(char*) * (n + 1));
+  (*argv_free) = (char**) main_malloc(sizeof(char*) * (n + 1));
   (*argv_out) = (*argv_free);
   (*argv_out)[0] = argv[0];
   (*argv_out)[n] = NULL;
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;