14 files changed, 156 insertions, 128 deletions

diff --git a/xdelta3/Makefile.am b/xdelta3/Makefile.am
index ab8c09a..dd2f2d5 100644
--- a/xdelta3/Makefile.am
+++ b/xdelta3/Makefile.am
@@ -57,7 +57,7 @@ if DEBUG_SYMBOLS
 endif
 
 # For additional debugging, add -DXD3_DEBUG=1, 2, 3, ...
-xdelta3_CFLAGS = $(C_WFLAGS) $(common_CFLAGS) -DXD3_DEBUG=2
+xdelta3_CFLAGS = $(C_WFLAGS) $(common_CFLAGS) -DXD3_DEBUG=0
 xdelta3_LDADD = -lm
 
 xdelta3decode_CFLAGS = \
diff --git a/xdelta3/configure.ac b/xdelta3/configure.ac
index 4d03e12..1feb7dd 100644
--- a/xdelta3/configure.ac
+++ b/xdelta3/configure.ac
@@ -1,4 +1,4 @@
-AC_INIT([Xdelta3], [3.0.5], [josh.macdonald@gmail.com], 
+AC_INIT([Xdelta3], [3.0.6], [josh.macdonald@gmail.com], 
         [xdelta3], [http://xdelta.org/])
 AC_PREREQ([2.68])
 AC_CONFIG_MACRO_DIR([m4])
diff --git a/xdelta3/xdelta3-blkcache.h b/xdelta3/xdelta3-blkcache.h
index a68a59a..82d720e 100644
--- a/xdelta3/xdelta3-blkcache.h
+++ b/xdelta3/xdelta3-blkcache.h
@@ -1,6 +1,6 @@
 /* xdelta 3 - delta compression tools and library
  * Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- * 2008, 2009, 2010, 2011, 2012, 2013
+ * 2008, 2009, 2010
  * Joshua P. MacDonald
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -18,6 +18,9 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+/* TODO: This code is heavily revised from 3.0z but still needs major
+ * refactoring. */
+
 #include "xdelta3-internal.h"
 
 typedef struct _main_blklru      main_blklru;
@@ -33,13 +36,13 @@ struct _main_blklru
 {
   uint8_t          *blk;
   xoff_t            blkno;
-  xoff_t            size;
+  usize_t           size;
   main_blklru_list  link;
 };
 
 #define MAX_LRU_SIZE 32U
 #define XD3_MINSRCWINSZ (XD3_ALLOCSIZE * MAX_LRU_SIZE)
-#define XD3_MAXSRCWINSZ (1ULL << 32)
+#define XD3_MAXSRCWINSZ (1ULL << 31)
 
 XD3_MAKELIST(main_blklru_list,main_blklru,link);
 
@@ -87,23 +90,32 @@ main_set_source (xd3_stream *stream, xd3_cmd cmd,
   int ret = 0;
   usize_t i;
   xoff_t source_size = 0;
+  usize_t blksize;
 
   XD3_ASSERT (lru == NULL);
   XD3_ASSERT (stream->src == NULL);
   XD3_ASSERT (option_srcwinsz >= XD3_MINSRCWINSZ);
 
+  /* TODO: this code needs refactoring into FIFO, LRU, FAKE.  Yuck!
+   * This is simplified from 3.0z which had issues with sizing the
+   * source buffer memory allocation and the source blocksize. */
+
   /* LRU-specific */
   main_blklru_list_init (& lru_list);
 
   if (allow_fake_source)
     {
+      /* TODO: refactor
+       * TOOLS/recode-specific: Check "allow_fake_source" mode looks
+       * broken now. */
       sfile->mode = XO_READ;
       sfile->realname = sfile->filename;
       sfile->nread = 0;
     }
   else
     {
-      /* Either a regular file or a FIFO. Both are possibly compressed. */
+      /* Either a regular file (possibly compressed) or a FIFO
+       * (possibly compressed). */
       if ((ret = main_file_open (sfile, sfile->filename, XO_READ)))
         {
           return ret;
@@ -141,24 +153,22 @@ main_set_source (xd3_stream *stream, xd3_cmd cmd,
       return ret;
     }
 
-  /* Setup LRU blocks. */
-  for (i = 0; i < MAX_LRU_SIZE; i++)
-    {
-      lru[i].blk = lru[0].blk + (option_srcwinsz / MAX_LRU_SIZE) * i;
-      lru[i].blkno = (xoff_t) -1;
-      lru[i].size = 0;
-      main_blklru_list_push_back (& lru_list, & lru[i]);
-    }
+  /* Main calls main_getblk_func() once before xd3_set_source().  This
+   * is the point at which external decompression may begin.  Set the
+   * system for a single block. */
+  lru_size = 1;
+  lru[0].blkno = (xoff_t) -1;
+  blksize = option_srcwinsz;
+  main_blklru_list_push_back (& lru_list, & lru[0]);
+  XD3_ASSERT (blksize != 0);
 
   /* Initialize xd3_source. */
+  source->blksize  = blksize;
   source->name     = sfile->filename;
   source->ioh      = sfile;
   source->curblkno = (xoff_t) -1;
   source->curblk   = NULL;
   source->max_winsize = option_srcwinsz;
-  source->blksize = option_srcwinsz;
-
-  lru_size = 1;
 
   if ((ret = main_getblk_func (stream, source, 0)) != 0)
     {
@@ -168,26 +178,44 @@ main_set_source (xd3_stream *stream, xd3_cmd cmd,
       return ret;
     }
 
-  /* If the file is smaller than the buffer, size is known. */
-  if (source->onblk < source->blksize)
+  source->onblk = lru[0].size;  /* xd3 sets onblk */
+
+  /* If the file is smaller than a block, size is known. */
+  if (!sfile->size_known && source->onblk < blksize)
     {
       source_size = source->onblk;
       sfile->size_known = 1;
     }
-  else
+
+  /* If the size is not known or is greater than the buffer size, we
+   * split the buffer across MAX_LRU_SIZE blocks (already allocated in
+   * "lru"). */
+  if (!sfile->size_known || source_size > option_srcwinsz)
     {
-      /* Split the buffer */
-      source->blksize = option_srcwinsz / MAX_LRU_SIZE;
-      source->onblk = source->blksize;
+      /* Modify block 0, change blocksize. */
+      blksize = option_srcwinsz / MAX_LRU_SIZE;
+      source->blksize = blksize;
+      source->onblk = blksize;  /* xd3 sets onblk */
+      /* Note: source->max_winsize is unchanged. */
+      lru[0].size = blksize;
       lru_size = MAX_LRU_SIZE;
 
-      for (i = 0; i < (int) MAX_LRU_SIZE; ++i)
+      /* Setup rest of blocks. */
+      for (i = 1; i < lru_size; i += 1)
         {
+          lru[i].blk = lru[0].blk + (blksize * i);
           lru[i].blkno = i;
-          lru[i].size = source->blksize;
+          lru[i].size = blksize;
+          main_blklru_list_push_back (& lru_list, & lru[i]);
         }
     }
 
+  if (! sfile->size_known)
+    {
+      /* If the size is not know, we must use FIFO discipline. */
+      do_src_fifo = 1;
+    }
+
   /* Call the appropriate set_source method, handle errors, print
    * verbose message, etc. */
   if (sfile->size_known)
@@ -196,8 +224,6 @@ main_set_source (xd3_stream *stream, xd3_cmd cmd,
     }
   else
     {
-      /* If the size is not known, we must use FIFO discipline. */
-      do_src_fifo = 1;
       ret = xd3_set_source (stream, source);
     }
 
@@ -208,6 +234,7 @@ main_set_source (xd3_stream *stream, xd3_cmd cmd,
     }
 
   XD3_ASSERT (stream->src == source);
+  XD3_ASSERT (source->blksize == blksize);
 
   if (option_verbose)
     {
@@ -238,7 +265,7 @@ main_set_source (xd3_stream *stream, xd3_cmd cmd,
       XPR(NT "source %s %s blksize %s window %s%s%s\n",
           sfile->filename,
           srcszbuf.buf,
-          main_format_bcnt (source->blksize, &blkszbuf),
+          main_format_bcnt (blksize, &blkszbuf),
           main_format_bcnt (option_srcwinsz, &winszbuf),
           nbufs.buf,
           do_src_fifo ? " (FIFO)" : "");
@@ -303,18 +330,10 @@ main_getblk_lru (xd3_source *source, xoff_t blkno,
   lru_filled += 1;
   (*is_new) = 1;
   (*blrup) = blru;
-  blru->blkno = (xoff_t) -1;
+  blru->blkno = -1;
   return 0;
 }
 
-/* Opens / seeks the source file and:
- * (a) determines the source stream blocksize
- * (b) determines the source file size (if possible)
- * (c) calls main_read_primary_input (i.e., start external decompression)
- *
- * The main difficulty concerns an optimization: if the entire source
- * fits inside the buffer, we decide to use a single block.
- */
 static int
 main_read_seek_source (xd3_stream *stream,
                        xd3_source *source,
@@ -384,7 +403,7 @@ main_read_seek_source (xd3_stream *stream,
       while (sfile->source_position < pos)
         {
           xoff_t skip_blkno;
-          xoff_t skip_offset;
+          usize_t skip_offset;
 
           xd3_blksize_div (sfile->source_position, source,
                            &skip_blkno, &skip_offset);
@@ -421,7 +440,7 @@ main_read_seek_source (xd3_stream *stream,
           sfile->source_position += nread;
           blru->size = nread;
 
-          IF_DEBUG1 (DP(RINT "[getblk] skip blkno %"Q"u size %"Q"u\n",
+          IF_DEBUG1 (DP(RINT "[getblk] skip blkno %"Q"u size %u\n",
                         skip_blkno, blru->size));
 
           XD3_ASSERT (sfile->source_position <= pos);
@@ -449,6 +468,7 @@ main_getblk_func (xd3_stream *stream,
   main_file *sfile = (main_file*) source->ioh;
   main_blklru *blru;
   int is_new;
+  int did_seek = 0;
   size_t nread = 0;
 
   if (allow_fake_source)
@@ -486,14 +506,19 @@ main_getblk_func (xd3_stream *stream,
           return ret;
         }
 
-      if ((ret = main_getblk_lru (source, blkno, & blru, & is_new)))
-        {
-          return ret;
-        }
+      /* Indicates that another call to main_getblk_lru() may be
+       * needed */
+      did_seek = 1;
     }
 
   XD3_ASSERT (sfile->source_position == pos);
 
+  if (did_seek &&
+      (ret = main_getblk_lru (source, blkno, & blru, & is_new)))
+    {
+      return ret;
+    }
+
   if ((ret = main_read_primary_input (sfile,
                                       (uint8_t*) blru->blk,
                                       source->blksize,
diff --git a/xdelta3/xdelta3-decode.h b/xdelta3/xdelta3-decode.h
index 2ffe4a7..c0cb578 100644
--- a/xdelta3/xdelta3-decode.h
+++ b/xdelta3/xdelta3-decode.h
@@ -428,8 +428,8 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
                  * copy. */
                 xd3_source *source = stream->src;
                 xoff_t block = source->cpyoff_blocks;
-                xoff_t blkoff = source->cpyoff_blkoff;
-                const xoff_t blksize = source->blksize;
+                usize_t blkoff = source->cpyoff_blkoff;
+                const usize_t blksize = source->blksize;
                 int ret;
 
                 xd3_blksize_add (&block, &blkoff, source, inst->addr);
@@ -454,7 +454,7 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
                     (blkoff + take > source->onblk))
                   {
                     IF_DEBUG1 (XPR(NT "[srcfile] short at blkno %"Q"u onblk "
-                                   "%"Q"u blksize %"Q"u blkoff %"Q"u take %u\n",
+                                   "%u blksize %u blkoff %u take %u\n",
                                    block,
                                    source->onblk,
                                    blksize,
@@ -475,7 +475,7 @@ xd3_decode_output_halfinst (xd3_stream *stream, xd3_hinst *inst)
                   }
                 else
                   {
-                    take = (usize_t) (blksize - blkoff);
+                    take = blksize - blkoff;
                     inst->size -= take;
                     inst->addr += take;
 
@@ -1095,8 +1095,8 @@ xd3_decode_input (xd3_stream *stream)
           IF_DEBUG1(DP(RINT
                        "decode cpyoff %"Q"u "
                        "cpyblkno %"Q"u "
-                       "cpyblkoff %"Q"u "
-                       "blksize %"Q"u\n",
+                       "cpyblkoff %u "
+                       "blksize %u\n",
                        stream->dec_cpyoff,
                        src->cpyoff_blocks,
                        src->cpyoff_blkoff,
diff --git a/xdelta3/xdelta3-fgk.h b/xdelta3/xdelta3-fgk.h
index b85e2c2..7011500 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;
-  int si;
+  ssize_t 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 = (int)(h->alphabet_size - 1U); si >= 0; si -= 1)
+  for (si = h->alphabet_size - 1; 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 = 1U << h->zero_freq_exp;
+  i = 1 << 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 dd74734..e359436 100644
--- a/xdelta3/xdelta3-hash.h
+++ b/xdelta3/xdelta3-hash.h
@@ -134,14 +134,14 @@ xd3_lcksum (const uint8_t *seg, const usize_t ln)
 
 #if XD3_ENCODER
 static usize_t
-xd3_size_log2 (size_t slots)
+xd3_size_log2 (usize_t slots)
 {
-  usize_t bits = 31;
-  usize_t i;
+  int bits = 28; /* This should not be an unreasonable limit. */
+  int i;
 
   for (i = 3; i <= bits; i += 1)
     {
-      if (slots < (1ULL << i))
+      if (slots < (1U << i))
         {
           /* TODO: this is compaction=1 in checksum_test.cc and maybe should
            * not be fixed at -1. */
@@ -155,12 +155,13 @@ xd3_size_log2 (size_t slots)
 
 static void
 xd3_size_hashtable (xd3_stream    *stream,
-                    size_t         slots,
+                    usize_t        slots,
                     xd3_hash_cfg  *cfg)
 {
-  usize_t bits = xd3_size_log2 (slots);
+  int bits = xd3_size_log2 (slots);
 
-  cfg->size  = (1U << bits);
+  /* TODO: there's a 32-bit assumption here */
+  cfg->size  = (1 << bits);
   cfg->mask  = (cfg->size - 1);
   cfg->shift = 32 - bits;
 }
diff --git a/xdelta3/xdelta3-internal.h b/xdelta3/xdelta3-internal.h
index 122cc02..13f4a34 100644
--- a/xdelta3/xdelta3-internal.h
+++ b/xdelta3/xdelta3-internal.h
@@ -40,7 +40,7 @@ int main_file_read (main_file  *ifile,
                     const char *msg);
 int main_file_write (main_file *ofile, uint8_t *buf, 
                      usize_t size, const char *msg);
-xoff_t xd3_bytes_on_srcblk (xd3_source *src, xoff_t blkno);
+usize_t xd3_bytes_on_srcblk (xd3_source *src, xoff_t blkno);
 xoff_t xd3_source_eof(const xd3_source *src);
 uint32_t xd3_large_cksum_update (uint32_t cksum,
                                  const uint8_t *base,
diff --git a/xdelta3/xdelta3-list.h b/xdelta3/xdelta3-list.h
index 9b3bc2b..6e3125f 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 size_t                                                    \
+static inline usize_t                                                   \
 LTYPE ## _length (LTYPE *l)                                             \
 {                                                                       \
   LTYPE *p;                                                             \
-  size_t c = 0;                                                         \
+  int c = 0;                                                            \
                                                                         \
   for (p = l->next; p != l; p = p->next)                                \
     {                                                                   \
diff --git a/xdelta3/xdelta3-main.h b/xdelta3/xdelta3-main.h
index b0bf370..af2336d 100644
--- a/xdelta3/xdelta3-main.h
+++ b/xdelta3/xdelta3-main.h
@@ -296,6 +296,9 @@ static main_extcomp extcomp_types[] =
   { "gzip",     "-c",   "gzip",       "-dc",   "G", "\037\213",     2, 0 },
   { "compress", "-c",   "uncompress", "-c",    "Z", "\037\235",     2, 0 },
 
+  /* TODO: add commandline support for magic-less formats */
+  /*{ "lzma", "-c",   "lzma", "-dc",   "M", "]\000", 2, 0 },*/
+
   /* Xz is lzma with a magic number http://tukaani.org/xz/ */
   { "xz", "-c", "xz", "-dc", "Y", "\xfd\x37\x7a\x58\x5a\x00", 2, 0 },
 };
@@ -357,7 +360,7 @@ static int
 main_version (void)
 {
   /* $Format: "  XPR(NTR \"Xdelta version $Xdelta3Version$, Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, Joshua MacDonald\\n\");" $ */
-  XPR(NTR "Xdelta version 3.0.5, Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, Joshua MacDonald\n");
+  XPR(NTR "Xdelta version 3.0.6, Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, Joshua MacDonald\n");
   XPR(NTR "Xdelta comes with ABSOLUTELY NO WARRANTY.\n");
   XPR(NTR "This is free software, and you are welcome to redistribute it\n");
   XPR(NTR "under certain conditions; see \"COPYING\" for details.\n");
@@ -2415,7 +2418,7 @@ main_secondary_decompress_check (main_file  *file,
 {
   int ret;
   usize_t i;
-  size_t try_read = min (input_size, XD3_ALLOCSIZE);
+  usize_t try_read = min (input_size, XD3_ALLOCSIZE);
   size_t  check_nread = 0;
   uint8_t check_buf[XD3_ALLOCSIZE];  /* TODO: stack limit */
   const main_extcomp *decompressor = NULL;
@@ -3227,8 +3230,8 @@ main_input (xd3_cmd     cmd,
                 main_get_appheader (& stream, ifile, ofile, sfile);
 
                 /* Now open the source file. */
-                if ((sfile->filename != NULL) &&
-                    (ret = main_set_source (& stream, cmd, sfile, & source)))
+                  if ((sfile->filename != NULL) &&
+                      (ret = main_set_source (& stream, cmd, sfile, & source)))
                   {
                     return EXIT_FAILURE;
                   }
diff --git a/xdelta3/xdelta3-second.h b/xdelta3/xdelta3-second.h
index 5fc93ed..b9830ab 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 = 1U << nbits;
+  usize_t vmask = 1 << 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 = 1U << nbits;
+  usize_t mask = 1 << nbits;
 
   XD3_ASSERT (nbits > 0);
   XD3_ASSERT (nbits < sizeof (usize_t) * 8);
diff --git a/xdelta3/xdelta3-test.h b/xdelta3/xdelta3-test.h
index a602a41..fe62a4b 100644
--- a/xdelta3/xdelta3-test.h
+++ b/xdelta3/xdelta3-test.h
@@ -669,13 +669,13 @@ test_forward_match (xd3_stream *stream, int unused)
 
   for (i = 0; i < 256; i++)
     {
-      CHECK(xd3_forward_match(buf1, buf2, i) == i);
+      CHECK(xd3_forward_match(buf1, buf2, i) == (int)i);
     }
 
   for (i = 0; i < 255; i++)
     {
       buf2[i] = 1;
-      CHECK(xd3_forward_match(buf1, buf2, 256) == i);
+      CHECK(xd3_forward_match(buf1, buf2, 256) == (int)i);
       buf2[i] = 0;
     }
 
diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index 23a6622..608622a 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 = 2U + desc->near_modes + desc->same_modes;
+  usize_t cpy_modes = 2 + desc->near_modes + desc->same_modes;
   xd3_dinst *d = tbl;
 
   (d++)->type1 = XD3_RUN;
@@ -1015,8 +1015,7 @@ 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;
@@ -1530,10 +1529,10 @@ xd3_swap_usize_t (usize_t* p1, usize_t* p2)
 
 /* It's not constant time, but it computes the log. */
 static int
-xd3_check_pow2 (xoff_t value, int *logof)
+xd3_check_pow2 (xoff_t value, usize_t *logof)
 {
   xoff_t x = 1;
-  int nolog;
+  usize_t nolog;
   if (logof == NULL) {
     logof = &nolog;
   }
@@ -1594,16 +1593,17 @@ 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 uint32_t adler32 (uint32_t adler, const uint8_t *buf, size_t len)
+static unsigned long adler32 (unsigned long adler, const uint8_t *buf, 
+                              usize_t len)
 {
-    uint32_t s1 = adler & 0xffff;
-    uint32_t s2 = (adler >> 16) & 0xffff;
+    unsigned long s1 = adler & 0xffff;
+    unsigned long s2 = (adler >> 16) & 0xffff;
     int k;
 
     while (len > 0)
       {
-        k    = (len < A32_NMAX) ? (int) len : A32_NMAX;
-        len -= (size_t) k;
+        k    = (len < A32_NMAX) ? len : A32_NMAX;
+        len -= k;
 
         while (k >= 16)
           {
@@ -2560,9 +2560,9 @@ xoff_t xd3_source_eof(const xd3_source *src)
 }
 
 inline
-xoff_t xd3_bytes_on_srcblk (xd3_source *src, xoff_t blkno)
+usize_t xd3_bytes_on_srcblk (xd3_source *src, xoff_t blkno)
 {
-  xoff_t r = (blkno == src->max_blkno ?
+  usize_t r = (blkno == src->max_blkno ?
                src->onlastblk :
                src->blksize);
   return r;
@@ -2653,7 +2653,7 @@ int
 xd3_set_source (xd3_stream *stream,
                 xd3_source *src)
 {
-  int shiftby;
+  usize_t shiftby;
 
   stream->src = src;
   src->srclen  = 0;
@@ -2665,16 +2665,16 @@ xd3_set_source (xd3_stream *stream,
     {
       src->blksize = xd3_pow2_roundup(src->blksize);
       xd3_check_pow2 (src->blksize, &shiftby);
-      IF_DEBUG1 (DP(RINT "raising src_blksz to %"Q"u\n", src->blksize));
+      IF_DEBUG1 (DP(RINT "raising src_blksz to %u\n", src->blksize));
     }
 
   src->shiftby = shiftby;
-  src->maskby = (1U << shiftby) - 1;
+  src->maskby = (1 << shiftby) - 1;
 
   if (xd3_check_pow2 (src->max_winsize, NULL) != 0)
     {
       src->max_winsize = xd3_xoff_roundup(src->max_winsize);
-      IF_DEBUG1 (DP(RINT "raising src_maxsize to %"Q"u\n", src->blksize));
+      IF_DEBUG1 (DP(RINT "raising src_maxsize to %u\n", src->blksize));
     }
   src->max_winsize = max(src->max_winsize, XD3_ALLOCSIZE);
 
@@ -3696,8 +3696,8 @@ xd3_encode_init (xd3_stream *stream, int full_init)
        * identical or short inputs require no table allocation. */
       if (large_comp)
         {
-          usize_t hash_values = (usize_t) (stream->src->max_winsize /
-                                 (xoff_t) stream->smatcher.large_step);
+          usize_t hash_values = (stream->src->max_winsize /
+                                 stream->smatcher.large_step);
 
           xd3_size_hashtable (stream,
                               hash_values,
@@ -4138,7 +4138,7 @@ xd3_process_memory (int            is_encode,
       config.winsize = min(input_size, (usize_t) XD3_DEFAULT_WINSIZE);
       config.iopt_size = min(input_size / 32, XD3_DEFAULT_IOPT_SIZE);
       config.iopt_size = max(config.iopt_size, 128U);
-      config.sprevsz = (usize_t) xd3_pow2_roundup (config.winsize);
+      config.sprevsz = xd3_pow2_roundup (config.winsize);
     }
 
   if ((ret = xd3_config_stream (&stream, &config)) != 0)
@@ -4560,21 +4560,19 @@ xd3_source_match_setup (xd3_stream *stream, xoff_t srcpos)
   return 1;
 }
 
-static inline xoff_t
-xd3_forward_match(const uint8_t *s1c, const uint8_t *s2c, size_t n)
+static inline int
+xd3_forward_match(const uint8_t *s1c, const uint8_t *s2c, int n)
 {
-  size_t i = 0;
-#if UNALIGNED_OK  
-  const size_t ssize = sizeof(size_t);
-  const size_t nint = n / ssize;
+  int i = 0;
+#if UNALIGNED_OK
+  int nint = n / sizeof(int);
 
-  /* If there are at least 8 elements */
   if (nint >> 3)
     {
-      usize_t j = 0;
-      const size_t *s1 = (const size_t*)s1c;
-      const size_t *s2 = (const size_t*)s2c;
-      const size_t nint_8 = nint - 8;
+      int j = 0;
+      const int *s1 = (const int*)s1c;
+      const int *s2 = (const int*)s2c;
+      int nint_8 = nint - 8;
 
       while (i <= nint_8 &&
              s1[i++] == s2[j++] &&
@@ -4586,7 +4584,7 @@ xd3_forward_match(const uint8_t *s1c, const uint8_t *s2c, size_t n)
              s1[i++] == s2[j++] &&
              s1[i++] == s2[j++]) { }
 
-      i = (i - 1) * ssize;
+      i = (i - 1) * sizeof(int);
     }
 #endif
 
@@ -4617,9 +4615,9 @@ xd3_source_extend_match (xd3_stream *stream)
                         of the input match being tested. */
   xoff_t tryblk;    /* tryblk, tryoff are the block, offset position
                        of matchoff */
-  xoff_t tryoff;
-  xoff_t tryrem;    /* tryrem is the number of matchable bytes */
-  xoff_t matched;
+  usize_t tryoff;
+  usize_t tryrem;    /* tryrem is the number of matchable bytes */
+  usize_t matched;
 
   IF_DEBUG2(DP(RINT "[extend match] srcpos %"Q"u\n",
                stream->match_srcpos));
@@ -4722,8 +4720,8 @@ xd3_source_extend_match (xd3_stream *stream)
                                   stream->next_in + streamoff,
                                   tryrem);
       tryoff += matched;
-      streamoff += (xoff_t) matched;
-      stream->match_fwd += (xoff_t) matched;
+      streamoff += matched;
+      stream->match_fwd += matched;
 
       if (tryrem != matched)
         {
@@ -5096,7 +5094,7 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
     {
       xoff_t  blkno;
       xoff_t  blkbaseoffset;
-      xoff_t blkrem;
+      usize_t blkrem;
       ssize_t oldpos;  /* Using ssize_t because of a  */
       ssize_t blkpos;  /* do { blkpos-- }
                           while (blkpos >= oldpos); */
@@ -5154,11 +5152,12 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
           usize_t hval = xd3_checksum_hash (& stream->large_hash, cksum);
 
           stream->large_table[hval] =
-            (uint32_t) (blkbaseoffset + (xoff_t)(blkpos + HASH_CKOFFSET));
+            (usize_t) (blkbaseoffset +
+                       (xoff_t)(blkpos + HASH_CKOFFSET));
 
           IF_DEBUG (stream->large_ckcnt += 1);
 
-          blkpos -= (ssize_t) stream->smatcher.large_step;
+          blkpos -= stream->smatcher.large_step;
         }
       while (blkpos >= oldpos);
 
diff --git a/xdelta3/xdelta3.h b/xdelta3/xdelta3.h
index c05df08..686e05c 100644
--- a/xdelta3/xdelta3.h
+++ b/xdelta3/xdelta3.h
@@ -110,6 +110,7 @@
  */
 #ifndef _WIN32
 #include <stdint.h>
+typedef uint32_t usize_t;
 #else
 #define WIN32_LEAN_AND_MEAN
 #if XD3_USE_LARGEFILE64
@@ -124,9 +125,10 @@
 #define _WIN32_WINNT    0x0400
 #endif
 #include <windows.h>
+typedef uint32_t usize_t;
 #ifdef _MSC_VER
 #define inline
-typedef signed long    ssize_t;
+typedef signed int     ssize_t;
 #if _MSC_VER < 1600
 typedef unsigned char  uint8_t;
 typedef unsigned short uint16_t;
@@ -142,8 +144,6 @@ typedef ULONGLONG      uint64_t;
 #endif
 #endif
 
-typedef uint32_t usize_t;
-
 #if XD3_USE_LARGEFILE64
 #define __USE_FILE_OFFSET64 1 /* GLIBC: for 64bit fileops, ... ? */
 #ifndef _LARGEFILE_SOURCE
@@ -632,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 */
@@ -718,7 +718,7 @@ struct _xd3_config
 struct _xd3_source
 {
   /* you set */
-  xoff_t              blksize;       /* block size */
+  usize_t             blksize;       /* block size */
   const char         *name;          /* its name, for debug/print
                                         purposes */
   void               *ioh;           /* opaque handle */
@@ -727,7 +727,7 @@ struct _xd3_source
   /* getblk sets */
   xoff_t              curblkno;      /* current block number: client
                                         sets after getblk request */
-  xoff_t              onblk;         /* number of bytes on current
+  usize_t             onblk;         /* number of bytes on current
                                         block: client sets,  must be >= 0
                                         and <= blksize */
   const uint8_t      *curblk;        /* current block array: client
@@ -738,9 +738,9 @@ struct _xd3_source
   xoff_t              srcbase;       /* offset of this source window
                                         in the source itself */
   int                 shiftby;       /* for power-of-two blocksizes */
-  usize_t             maskby;        /* for power-of-two blocksizes */
+  int                 maskby;        /* for power-of-two blocksizes */
   xoff_t              cpyoff_blocks; /* offset of dec_cpyoff in blocks */
-  xoff_t              cpyoff_blkoff; /* offset of copy window in
+  usize_t             cpyoff_blkoff; /* offset of copy window in
                                         blocks, remainder */
   xoff_t              getblkno;      /* request block number: xd3 sets
                                         current getblk request */
@@ -753,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 */
+  usize_t             onlastblk;  /* Number of bytes on max_blkno */
   int                 eof_known;  /* Set to true when the first
                                    * partial block is read. */
 };
@@ -808,10 +808,10 @@ struct _xd3_stream
 
   xd3_smatcher      smatcher;
 
-  uint32_t          *large_table;      /* table of large checksums */
+  usize_t           *large_table;      /* table of large checksums */
   xd3_hash_cfg       large_hash;       /* large hash config */
 
-  uint32_t          *small_table;      /* table of small checksums */
+  usize_t           *small_table;      /* table of small checksums */
   xd3_slist         *small_prev;       /* table of previous offsets,
                                           circular linked list */
   int                small_reset;      /* true if small table should
@@ -1315,19 +1315,19 @@ static inline
 void xd3_blksize_div (const xoff_t offset,
                       const xd3_source *source,
                       xoff_t *blkno,
-                      xoff_t *blkoff) {
+                      usize_t *blkoff) {
   *blkno = (xoff_t) (offset >> source->shiftby);
-  *blkoff = (xoff_t) (offset & source->maskby);
+  *blkoff = (usize_t) (offset & source->maskby);
   XD3_ASSERT (*blkoff < source->blksize);
 }
 
 static inline
 void xd3_blksize_add (xoff_t *blkno,
-                      xoff_t *blkoff,
+                      usize_t *blkoff,
                       const xd3_source *source,
                       const usize_t add)
 {
-  xoff_t blkdiff;
+  usize_t blkdiff;
 
   /* Does not check for overflow, checked in xdelta3-decode.h. */
   *blkoff += add;
diff --git a/xdelta3/xdelta3.prj b/xdelta3/xdelta3.prj
index 96abed7..74aaa8a 100644
--- a/xdelta3/xdelta3.prj
+++ b/xdelta3/xdelta3.prj
@@ -9,7 +9,7 @@
 (Checkin-Login jmacd)
 (Populate-Ignore ("\\.svn"))
 (Project-Keywords
- (Xdelta3Version "3.0.5")
+ (Xdelta3Version "3.0.6")
  )
 (Files
   (COPYING (xdelta3/b/29_COPYING 1.1 744))