5 files changed, 217 insertions, 278 deletions

diff --git a/xdelta3/xdelta3-cfgs.h b/xdelta3/xdelta3-cfgs.h
index 329f3e9..b7b8f72 100755
--- a/xdelta3/xdelta3-cfgs.h
+++ b/xdelta3/xdelta3-cfgs.h
@@ -23,16 +23,16 @@
 #if XD3_BUILD_SOFT
 
 #define TEMPLATE      soft
-#define LLOOK         stream->large_look
-#define LSTEP         stream->large_step
-#define SLOOK         stream->small_look
-#define SCHAIN        stream->small_chain
-#define SLCHAIN       stream->small_lchain
-#define SSMATCH       stream->ssmatch
-#define TRYLAZY       stream->try_lazy
-#define MAXLAZY       stream->max_lazy
-#define LONGENOUGH    stream->long_enough
-#define PROMOTE       stream->promote
+#define LLOOK         stream->smatcher.large_look
+#define LSTEP         stream->smatcher.large_step
+#define SLOOK         stream->smatcher.small_look
+#define SCHAIN        stream->smatcher.small_chain
+#define SLCHAIN       stream->smatcher.small_lchain
+#define SSMATCH       stream->smatcher.ssmatch
+#define TRYLAZY       stream->smatcher.try_lazy
+#define MAXLAZY       stream->smatcher.max_lazy
+#define LONGENOUGH    stream->smatcher.long_enough
+#define PROMOTE       stream->smatcher.promote
 
 #define SOFTCFG 1
 #include "xdelta3.c"
diff --git a/xdelta3/xdelta3-main.h b/xdelta3/xdelta3-main.h
index 4af4b87..0fe848c 100755
--- a/xdelta3/xdelta3-main.h
+++ b/xdelta3/xdelta3-main.h
@@ -29,23 +29,11 @@
  * 7. basic file support and OS interface
  */
 
-/* Definite TODO list:
+/* TODO list:
  * 1. do exact gzip-like filename, stdout handling.  make a .xz extension, refuse
  *    to encode to stdout without -cf, etc.
  * 2. Allow the user to add a comment string to the app header without disturbing the default
  *    behavior.
- * 3. Define zero-length window behavior
- * 4. Separate getopt() code from main and make flags modular, implement help.
- * 5. Catch up on related research!
- */
-
-/* Nice idea TODO list:
- *
- * 1. Should probably have a write buffer (option)?
- * 2. Add a reporting function for displaying progress, warning messages out of the library.
- * 3. Add WIN32 support in addition to XD3_POSIX/XD3_STDIO.  Should almost compile under windows
- *    with XD3_STDIO, but not quite (e.g., stat()?).
- * 4. Update-in-place, partial-encoding per the latest RFC: see "Wishful TODO" comments below
  */
 
 /* On error handling and printing:
@@ -72,13 +60,8 @@
 #endif
 
 /* XPRINTX (used by main) prefixes an "xdelta3: " to the output. */
-#if 0 && XD3_DEBUG
-#define XPR fprintf (stderr, "xdelta3[%u]: ", getpid()); fprintf
-#define NT stderr,
-#else
 #define XPR fprintf
 #define NT stderr, "xdelta3: "
-#endif
 
 #define VC fprintf
 #define OUT vcout,
@@ -96,11 +79,8 @@
 
 #define PRINTHDR_SPECIAL -4378291
 
-#define PIPE_BUFSIZE (usize_t)(1 << 12)
-#define MIN_BUFSIZE (usize_t)(1 << 12)
-
-/* The number of soft-config variables.  Update as field count changes! */
-#define XD3_SOFTCFG_VARCNT 10
+/* The number of soft-config variables.  */
+#define XD3_SOFTCFG_VARCNT 1
 
 /* this is used as in XPR(NT XD3_LIB_ERRMSG (stream, ret)) to print an error message
  * from the library. */
@@ -250,6 +230,7 @@ static const char *option_source_filename    = NULL;
 
 static usize_t     option_winsize            = XD3_DEFAULT_WINSIZE;
 static usize_t     option_srcwinsz           = XD3_DEFAULT_SRCWINSZ;
+static usize_t     option_memsize            = XD3_DEFAULT_MEMSIZE;
 
 /* Wishful TODO: Support should probably be for partial deltas & update-in-place deltas,
  * following the latest draft RFC specs partial deltas [the changes have moderate
@@ -345,16 +326,19 @@ main_config (void)
   P(RINT "XD3_DEBUG=%d\n", XD3_DEBUG);
   P(RINT "XD3_USE_LARGEFILE64=%d\n", XD3_USE_LARGEFILE64);
   P(RINT "XD3_ENCODER=%d\n", XD3_ENCODER);
-  /* Runtime sizes */
+
+  /* Runtime sizes/command-line */
   P(RINT "XD3_DEFAULT_WINSIZE=%d\n", XD3_DEFAULT_WINSIZE);
-  P(RINT "XD3_DEFAULT_SRCBLKSZ=%d\n", XD3_DEFAULT_SRCBLKSZ);
   P(RINT "XD3_DEFAULT_SRCWINSZ=%d\n", XD3_DEFAULT_SRCWINSZ);
   P(RINT "XD3_DEFAULT_MEMSIZE=%d\n", XD3_DEFAULT_MEMSIZE);
+
+  /* TODO: the following cannot be set by command-line */
   P(RINT "XD3_ALLOCSIZE=%d\n", XD3_ALLOCSIZE);
-  P(RINT "XD3_HARDMAXWINSIZE=%d\n", XD3_HARDMAXWINSIZE);
-  P(RINT "XD3_NODECOMPRESSSIZE=%d\n", XD3_NODECOMPRESSSIZE);
+  P(RINT "XD3_DEFAULT_CKSUM_SIZE=%d\n", XD3_DEFAULT_CKSUM_ADVANCE);
   P(RINT "XD3_DEFAULT_IOPT_SIZE=%d\n", XD3_DEFAULT_IOPT_SIZE);
   P(RINT "XD3_DEFAULT_SPREVSZ=%d\n", XD3_DEFAULT_SPREVSZ);
+  P(RINT "XD3_HARDMAXWINSIZE=%d\n", XD3_HARDMAXWINSIZE);
+  P(RINT "XD3_NODECOMPRESSSIZE=%d\n", XD3_NODECOMPRESSSIZE);
 
   return EXIT_SUCCESS;
 }
@@ -1271,10 +1255,10 @@ main_decompress_input_check (main_file   *ifile,
 {
   int i;
   int ret;
-  uint8_t check_buf[PIPE_BUFSIZE];
+  uint8_t check_buf[XD3_ALLOCSIZE];
   usize_t  check_nread;
 
-  if ((ret = main_file_read (ifile, check_buf, min (input_size, PIPE_BUFSIZE), & check_nread, "input read failed")))
+  if ((ret = main_file_read (ifile, check_buf, min (input_size, XD3_ALLOCSIZE), & check_nread, "input read failed")))
     {
       return ret;
     }
@@ -1299,7 +1283,7 @@ main_decompress_input_check (main_file   *ifile,
 
           return main_input_decompress_setup (decomp, ifile,
                                               input_buf, input_size,
-                                              check_buf, PIPE_BUFSIZE,
+                                              check_buf, XD3_ALLOCSIZE,
                                               check_nread, nread);
         }
     }
@@ -1307,9 +1291,9 @@ main_decompress_input_check (main_file   *ifile,
   /* Now read the rest of the input block. */
   (*nread) = 0;
 
-  if (check_nread == PIPE_BUFSIZE)
+  if (check_nread == XD3_ALLOCSIZE)
     {
-      ret = main_file_read (ifile, input_buf + PIPE_BUFSIZE, input_size - PIPE_BUFSIZE, nread, "input read failed");
+      ret = main_file_read (ifile, input_buf + XD3_ALLOCSIZE, input_size - XD3_ALLOCSIZE, nread, "input read failed");
     }
 
   memcpy (input_buf, check_buf, check_nread);
@@ -1834,11 +1818,23 @@ main_set_source (xd3_stream *stream, int cmd, main_file *sfile, xd3_source *sour
 
   if (option_verbose > 1) { XPR(NT "source window size: %u\n", option_srcwinsz); }
   if (option_verbose > 1) { XPR(NT "source block size: %u\n", source->blksize); }
-  
+  if (option_verbose > 1) { XPR(NT "memory size: %u\n", option_memsize); }
+
   lru_size = (option_srcwinsz / source->blksize);
   lru_size = max(1, lru_size);
 
-  XD3_ASSERT(lru_size <= 128);  /* TODO: fix performance here */
+  if (lru_size > 128)
+    {
+      /* TODO: fix performance here, the LRU is scanned sequentially to find blocks,
+       * except in encode, where it uses FIFO.  Fix is to set source->blksize
+       * accordingly. */
+      if (IS_ENCODE(cmd) && ! option_quiet)
+        {
+          XPR(NT "warning: large source window (--B %u) "
+                 "hurts performance except for encoding\n",
+              option_srcwinsz);
+        }
+    }
 
   if ((lru = main_malloc (sizeof (main_blklru) * lru_size)) == NULL)
     {
@@ -2179,18 +2175,16 @@ main_input (xd3_cmd     cmd,
                 }
             }
 
-          config.large_look    = values[0];
-          config.large_step    = values[1];
-          config.small_look    = values[2];
-          config.small_chain   = values[3];
-          config.small_lchain  = values[4];
-          config.ssmatch       = values[5];
-          config.try_lazy      = values[6];
-          config.max_lazy      = values[7];
-          config.long_enough   = values[8];
-          config.promote       = values[9];
-          config.srcwin_size   = values[10];
-          config.srcwin_maxsz  = values[11];
+          config.smatcher_soft.large_look    = values[0];
+          config.smatcher_soft.large_step    = values[1];
+          config.smatcher_soft.small_look    = values[2];
+          config.smatcher_soft.small_chain   = values[3];
+          config.smatcher_soft.small_lchain  = values[4];
+          config.smatcher_soft.ssmatch       = values[5];
+          config.smatcher_soft.try_lazy      = values[6];
+          config.smatcher_soft.max_lazy      = values[7];
+          config.smatcher_soft.long_enough   = values[8];
+          config.smatcher_soft.promote       = values[9];
         }
       else if (option_level < 5) { config.smatch_cfg = XD3_SMATCH_FAST; }
       else                       { config.smatch_cfg = XD3_SMATCH_SLOW; }
@@ -2210,33 +2204,32 @@ main_input (xd3_cmd     cmd,
 
   start_time = get_millisecs_now ();
 
-  /* allocate an input buffer.  min(file_size, option_winsize) */
-  {
-    xoff_t input_size = 0;
-    config.winsize = option_winsize;
-    if (main_file_stat (ifile, & input_size, 0) == 0)
-      {
-        config.winsize = min (input_size, (xoff_t) option_winsize);
-      }
-    config.winsize = max (config.winsize, MIN_BUFSIZE);
-  }
-  {
-    /* Source blocksize is not user-settable, only option_srcwinsz is,
-     * which determines the number of blocks. */
-    source.blksize = XD3_DEFAULT_SRCBLKSZ;
-    option_srcwinsz = max(option_srcwinsz, MIN_BUFSIZE);
-    config.srcwin_maxsz = option_srcwinsz;
-  }
-
-  if (option_verbose > 1) { XPR(NT "input buffer size: %u\n", config.winsize); }
-  
-  if ((main_bdata = main_malloc (config.winsize)) == NULL)
+  xoff_t input_size = 0;
+  if (main_file_stat (ifile, & input_size, 0) == 0)
     {
-      return EXIT_FAILURE;
+      option_winsize = min (input_size, (xoff_t) option_winsize);
     }
 
+  option_srcwinsz = max(option_srcwinsz, XD3_ALLOCSIZE);
+  option_winsize = max(option_winsize, XD3_ALLOCSIZE);
+
+  source.blksize = max(XD3_DEFAULT_WINSIZE, option_srcwinsz / 32);
+
+  config.srcwin_maxsz = option_srcwinsz;
+  config.winsize = option_winsize;
+  config.memsize = option_memsize;
   config.getblk = main_getblk_func;
-  config.flags  = stream_flags;
+  config.flags = stream_flags;
+
+  if (option_verbose > 1)
+    {
+      XPR(NT "input buffer size: %u\n", option_winsize);
+    }
+
+  if ((main_bdata = main_malloc (option_winsize)) == NULL)
+    {
+      return EXIT_FAILURE;
+    }
 
   if ((ret = xd3_config_stream (& stream, & config)))
     {
@@ -2254,14 +2247,6 @@ main_input (xd3_cmd     cmd,
         }
     }
 
-  /*XD3_ASSERT (option_first_offset <= option_last_offset);*/
-  /*XD3_ASSERT (option_first_window <= option_last_window);*/
-
-  /*if (option_first_offset != 0 && (ret = main_file_seek (ifile, option_first_offset)))
-    {
-      return EXIT_FAILURE;
-      }*/
-
   /* This times each window. */
   get_millisecs_since ();
 
@@ -2558,7 +2543,7 @@ main (int argc, char **argv)
   main_file ifile;
   main_file ofile;
   main_file sfile;
-  static char *flags = "0123456789cdefhnqvDJNRTVs:B:C:E:F:L:O:P:W:A::S::";
+  static char *flags = "0123456789cdefhnqvDJNRTVs:B:C:E:F:L:O:P:M:W:A::S::";
   int my_optind;
   char *my_optarg;
   char *my_optstr;
@@ -2720,12 +2705,6 @@ main (int argc, char **argv)
           XPR(NT "encoder support not compiled\n");
           return EXIT_FAILURE;
 #endif    
-
-          //case 'F': if ((ret = main_strtoxoff (my_optarg, & option_first_window, 'F'))) { goto exit; } break;
-          //case 'L': if ((ret = main_strtoxoff (my_optarg, & option_last_window, 'L'))) { goto exit; } break;
-          //case 'O': if ((ret = main_strtoxoff (my_optarg, & option_first_offset, 'O'))) { goto exit; } break;
-          //case 'E': if ((ret = main_strtoxoff (my_optarg, & option_last_offset, 'E'))) { goto exit; } break;
-
         case 'P':
           /* only set profile count once, since... */
           if (option_profile_cnt == 0)
@@ -2749,8 +2728,21 @@ main (int argc, char **argv)
                   else { option_use_secondary = 1; option_secondary = my_optarg; } break;
         case 'A': if (my_optarg == NULL) { option_use_appheader = 0; }
                   else { option_appheader = (uint8_t*) my_optarg; } break;
-        case 'B': if ((ret = main_atou (my_optarg, & option_srcwinsz, MIN_BUFSIZE, 'B'))) { goto exit; } break;
-        case 'W': if ((ret = main_atou (my_optarg, & option_winsize, MIN_BUFSIZE, 'W'))) { goto exit; } break;
+        case 'B': if ((ret = main_atou (my_optarg, & option_srcwinsz, XD3_ALLOCSIZE, 'B')))
+          {
+            goto exit;
+          }
+          break;
+        case 'W': if ((ret = main_atou (my_optarg, & option_winsize, XD3_ALLOCSIZE, 'W')))
+          {
+            goto exit;
+          }
+          break;
+        case 'M': if ((ret = main_atou (my_optarg, & option_memsize, XD3_ALLOCSIZE, 'M')))
+          {
+            goto exit;
+          }
+          break;
         case 'D':
 #if EXTERNAL_COMPRESSION == 0
           if (! option_quiet)
@@ -2918,44 +2910,46 @@ main (int argc, char **argv)
 static int
 main_help (void)
 {
-  /* Not all options are shown, yet: 0-9, l J T C P F L O E
-   * Remember to update www/xdelta3-cmdline.html
-   */ 
-
+  /* TODO: update www/xdelta3-cmdline.html */ 
   main_version ();
   P(RINT "usage: xdelta3 [command/options] [input [output]]\n");
   P(RINT "commands are:\n");
-  P(RINT "    encode      encodes the input%s\n", XD3_ENCODER ? "" : " [Not compiled]");
-  P(RINT "    decode      decodes the input\n");
   P(RINT "    config      prints xdelta3 configuration\n");
+  P(RINT "    decode      decodes the input\n");
+  P(RINT "    encode      encodes the input%s\n", XD3_ENCODER ? "" : " [Not compiled]");
 #if REGRESSION_TEST
   P(RINT "    test        run the builtin tests\n");
 #endif
 #if VCDIFF_TOOLS
   P(RINT "special commands for VCDIFF inputs:\n");
+  P(RINT "    printdelta  print information about the entire delta\n");
   P(RINT "    printhdr    print information about the first window\n");
   P(RINT "    printhdrs   print information about all windows\n");
-  P(RINT "    printdelta  print information about the entire delta\n");
 #endif
   P(RINT "options are:\n");
+  P(RINT "   -0 .. -9     compression level\n");
+  P(RINT "   -A [apphead] disable/provide application header\n");
+  P(RINT "   -B blksize   source file block size\n");
+  P(RINT "   -C           soft config (see code)\n");
   P(RINT "   -c           use stdout instead of default\n");
+  P(RINT "   -D           disable external decompression (encode/decode)\n");
   P(RINT "   -d           same as decode command\n");
   P(RINT "   -e           same as encode command\n");
   P(RINT "   -f           force overwrite\n");
+  P(RINT "   -h           show help\n");
+  P(RINT "   -J           disable output (check/compute only)\n");
+  P(RINT "   -M memsize   memory budget for hash tables\n");
   P(RINT "   -n           disable checksum (encode/decode)\n");
-  P(RINT "   -D           disable external decompression (encode/decode)\n");
-  P(RINT "   -R           disable external recompression (decode)\n");
   P(RINT "   -N           disable small string-matching compression\n");
+  P(RINT "   -P           repeat count (for profiling)\n");
+  P(RINT "   -q           be quiet\n");
+  P(RINT "   -R           disable external recompression (decode)\n");
   P(RINT "   -S [djw|fgk] disable/enable secondary compression\n");
-  P(RINT "   -A [apphead] disable/provide application header\n");
   P(RINT "   -s source    source file to copy from (if any)\n");
-  P(RINT "   -B blksize   source file block size\n");
-  P(RINT "   -W winsize   input window buffer size\n");
+  P(RINT "   -T           use alternate code table (compatibility testing)\n");
   P(RINT "   -v           be verbose (max 2)\n");
-  P(RINT "   -q           be quiet\n");
-  P(RINT "   -h           show help\n");
   P(RINT "   -V           show version\n");
-  P(RINT "   -P           repeat count (for profiling)\n");
+  P(RINT "   -W winsize   input window buffer size\n");
 
   return EXIT_FAILURE;
 }
diff --git a/xdelta3/xdelta3-test.h b/xdelta3/xdelta3-test.h
index 6ae43d7..d076656 100755
--- a/xdelta3/xdelta3-test.h
+++ b/xdelta3/xdelta3-test.h
@@ -2014,23 +2014,23 @@ test_string_matching (xd3_stream *stream, int ignore)
       xd3_init_config (& config, 0);
 
       config.smatch_cfg   = XD3_SMATCH_SOFT;
-      config.large_look   = 4;
-      config.large_step   = 4;
-      config.small_look   = 4;
-      config.small_chain  = 10;
-      config.small_lchain = 10;
-      config.max_lazy     = 10;
-      config.long_enough  = 10;
-      config.ssmatch      = (test->flags & SM_SSMATCH) && 1;
-      config.try_lazy     = (test->flags & SM_LAZY) && 1;
-      config.promote      = (test->flags & SM_PROMOTE) && 1;
+      config.smatcher_soft.large_look   = 4;
+      config.smatcher_soft.large_step   = 4;
+      config.smatcher_soft.small_look   = 4;
+      config.smatcher_soft.small_chain  = 10;
+      config.smatcher_soft.small_lchain = 10;
+      config.smatcher_soft.max_lazy     = 10;
+      config.smatcher_soft.long_enough  = 10;
+      config.smatcher_soft.ssmatch      = (test->flags & SM_SSMATCH) && 1;
+      config.smatcher_soft.try_lazy     = (test->flags & SM_LAZY) && 1;
+      config.smatcher_soft.promote      = (test->flags & SM_PROMOTE) && 1;
 
       if ((ret = xd3_config_stream (stream, & config))) { return ret; }
       if ((ret = xd3_encode_init (stream))) { return ret; }
 
       xd3_avail_input (stream, (uint8_t*)test->input, len);
 
-      if ((ret = stream->string_match (stream))) { return ret; }
+      if ((ret = stream->smatcher.string_match (stream))) { return ret; }
 
       *rptr = 0;
       while (! xd3_rlist_empty (& stream->iopt.used))
@@ -2093,16 +2093,16 @@ test_iopt_flush_instructions (xd3_stream *stream, int ignore)
   xd3_init_config (& config, 0);
 
   config.smatch_cfg    = XD3_SMATCH_SOFT;
-  config.large_look    = 16;
-  config.large_step    = 16;
-  config.small_look    = 4;
-  config.small_chain   = 128;
-  config.small_lchain  = 16;
-  config.ssmatch       = 0;
-  config.try_lazy      = 1;
-  config.max_lazy      = 8;
-  config.long_enough   = 128;
-  config.promote       = 0;
+  config.smatcher_soft.large_look    = 16;
+  config.smatcher_soft.large_step    = 16;
+  config.smatcher_soft.small_look    = 4;
+  config.smatcher_soft.small_chain   = 128;
+  config.smatcher_soft.small_lchain  = 16;
+  config.smatcher_soft.ssmatch       = 0;
+  config.smatcher_soft.try_lazy      = 1;
+  config.smatcher_soft.max_lazy      = 8;
+  config.smatcher_soft.long_enough   = 128;
+  config.smatcher_soft.promote       = 0;
 
   if ((ret = xd3_config_stream (stream, & config))) { return ret; }
 
diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index c99ba6f..f7514e5 100755
--- a/xdelta3/xdelta3.c
+++ b/xdelta3/xdelta3.c
@@ -478,10 +478,10 @@ IF_BUILD_SLOW(static const xd3_smatcher    __smatcher_slow;)
 #if XD3_DEBUG
 #define SMALL_HASH_DEBUG1(s,inp)                                  \
   usize_t debug_hval = xd3_checksum_hash (& (s)->small_hash,       \
-         xd3_scksum ((inp), (s)->small_look))
+         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)->small_look)))
+         xd3_scksum ((inp), (s)->smatcher.small_look)))
 #define SMALL_HASH_STATS(x) x
 #else
 #define SMALL_HASH_DEBUG1(s,inp)
@@ -489,21 +489,6 @@ IF_BUILD_SLOW(static const xd3_smatcher    __smatcher_slow;)
 #define SMALL_HASH_STATS(x)
 #endif /* XD3_DEBUG */
 
-/* Config fields: three structures contain these variables, so this is non-typed. */
-#define XD3_COPY_CONFIG_FIELDS(dst,src)       \
-  do {                                        \
-  (dst)->large_look    = (src)->large_look;   \
-  (dst)->large_step    = (src)->large_step;   \
-  (dst)->small_look    = (src)->small_look;   \
-  (dst)->small_chain   = (src)->small_chain;  \
-  (dst)->small_lchain  = (src)->small_lchain; \
-  (dst)->ssmatch       = (src)->ssmatch;      \
-  (dst)->try_lazy      = (src)->try_lazy;     \
-  (dst)->max_lazy      = (src)->max_lazy;     \
-  (dst)->long_enough   = (src)->long_enough;  \
-  (dst)->promote       = (src)->promote;      \
-  } while (0)
-
 /* 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)
 
@@ -1190,20 +1175,21 @@ int xd3_compute_code_table_encoding (xd3_stream *in_stream, const xd3_dinst *cod
 
   /* Be exhaustive. */
   config.sprevsz = 1<<11;
-  config.memsize = CODE_TABLE_STRING_SIZE * 10;
-
-  config.large_look    = 4;
-  config.large_step    = 1;
-  config.small_look    = 4;
-  config.small_chain   = CODE_TABLE_STRING_SIZE;
-  config.small_lchain  = CODE_TABLE_STRING_SIZE;
-  config.ssmatch       = 1;
-  config.try_lazy      = 1;
-  config.max_lazy      = CODE_TABLE_STRING_SIZE;
-  config.long_enough   = CODE_TABLE_STRING_SIZE;
-  config.promote       = 1;
-  config.srcwin_size   = CODE_TABLE_STRING_SIZE;
-  config.srcwin_maxsz  = CODE_TABLE_STRING_SIZE;
+  config.memsize = CODE_TABLE_STRING_SIZE;
+  config.srcwin_size = CODE_TABLE_STRING_SIZE;
+  config.srcwin_maxsz = CODE_TABLE_STRING_SIZE;
+
+  config.smatch_cfg = XD3_SMATCH_SOFT;
+  config.smatcher_soft.large_look    = 4;
+  config.smatcher_soft.large_step    = 1;
+  config.smatcher_soft.small_look    = 4;
+  config.smatcher_soft.small_chain   = CODE_TABLE_STRING_SIZE;
+  config.smatcher_soft.small_lchain  = CODE_TABLE_STRING_SIZE;
+  config.smatcher_soft.ssmatch       = 1;
+  config.smatcher_soft.try_lazy      = 1;
+  config.smatcher_soft.max_lazy      = CODE_TABLE_STRING_SIZE;
+  config.smatcher_soft.long_enough   = CODE_TABLE_STRING_SIZE;
+  config.smatcher_soft.promote       = 1;
 
   if ((ret = xd3_config_stream (& stream, & config))) { goto fail; }
 
@@ -2432,11 +2418,11 @@ xd3_rtype_to_string (xd3_rtype type, int print_mode)
 
 int
 xd3_config_stream(xd3_stream *stream,
-                   xd3_config *config)
+                  xd3_config *config)
 {
   int ret;
   xd3_config defcfg;
-  const xd3_smatcher* smatcher;
+  xd3_smatcher *smatcher = &stream->smatcher;
 
   if (config == NULL)
     {
@@ -2450,17 +2436,16 @@ xd3_config_stream(xd3_stream *stream,
   stream->memsize   = config->memsize   ? config->memsize : XD3_DEFAULT_MEMSIZE;
   stream->winsize   = config->winsize   ? config->winsize : XD3_DEFAULT_WINSIZE;
   stream->sprevsz   = config->sprevsz   ? config->sprevsz : XD3_DEFAULT_SPREVSZ;
-  stream->srcwin_size  = config->srcwin_size ? config->srcwin_size : XD3_DEFAULT_START_CKSUM_ADVANCE;
-  stream->srcwin_maxsz = config->srcwin_maxsz ? config->srcwin_maxsz : XD3_DEFAULT_MAX_CKSUM_ADVANCE;
   stream->iopt_size = config->iopt_size ? config->iopt_size : XD3_DEFAULT_IOPT_SIZE;
+  stream->srcwin_size  = config->srcwin_size ? config->srcwin_size : XD3_DEFAULT_CKSUM_ADVANCE;
+  stream->srcwin_maxsz = config->srcwin_maxsz ? config->srcwin_maxsz : XD3_DEFAULT_SRCWINSZ;
+
   stream->getblk    = config->getblk;
   stream->alloc     = config->alloc ? config->alloc : __xd3_alloc_func;
   stream->free      = config->freef ? config->freef : __xd3_free_func;
   stream->opaque    = config->opaque;
   stream->flags     = config->flags;
 
-  XD3_ASSERT (stream->winsize > 0);
-
   /* Secondary setup. */
   stream->sec_data  = config->sec_data;
   stream->sec_inst  = config->sec_inst;
@@ -2517,7 +2502,7 @@ xd3_config_stream(xd3_stream *stream,
   }
 
   /* Check sprevsz */
-  if (config->small_chain == 1)
+  if (smatcher->small_chain == 1)
     {
       stream->sprevsz = 0;
     }
@@ -2536,45 +2521,36 @@ xd3_config_stream(xd3_stream *stream,
   switch (config->smatch_cfg)
     {
       IF_BUILD_SOFT(case XD3_SMATCH_SOFT:
-      smatcher = & __smatcher_soft; break;
-
-      if (config->large_look  < MIN_MATCH ||
-          config->large_step  < 1         ||
-          config->small_look  < MIN_MATCH ||
-          config->small_chain < 1         ||
-          config->large_look  < config->small_look ||
-          config->small_chain < config->small_lchain ||
-          (config->small_lchain == 0 && config->try_lazy) ||
-          config->srcwin_size < stream->large_look ||
-          config->srcwin_maxsz < stream->srcwin_size)
-        {
-          stream->msg = "invalid soft string-match config";
-          return XD3_INTERNAL;
-        }
-      break;)
+      {
+        *smatcher = config->smatcher_soft;
+        smatcher->string_match = __smatcher_soft.string_match;
+        smatcher->name = __smatcher_soft.name;
+        if (smatcher->large_look  < MIN_MATCH ||
+            smatcher->large_step  < 1         ||
+            smatcher->small_look  < MIN_MATCH ||
+            smatcher->small_chain < 1         ||
+            smatcher->large_look  < smatcher->small_look ||
+            smatcher->small_chain < smatcher->small_lchain ||
+            (smatcher->small_lchain == 0 && smatcher->try_lazy))
+          {
+            stream->msg = "invalid soft string-match config";
+            return XD3_INTERNAL;
+          }
+        break;
+      })
 
       IF_BUILD_SLOW(case XD3_SMATCH_DEFAULT:)
-      IF_BUILD_SLOW(case XD3_SMATCH_SLOW: smatcher = & __smatcher_slow; break;)
-      IF_BUILD_FAST(case XD3_SMATCH_FAST: smatcher = & __smatcher_fast; break;)
+      IF_BUILD_SLOW(case XD3_SMATCH_SLOW:
+                    *smatcher = __smatcher_slow;
+                    break;)
+      IF_BUILD_FAST(case XD3_SMATCH_FAST:
+                    *smatcher = __smatcher_fast;
+                    break;)
     default:
       stream->msg = "invalid string match config type";
       return XD3_INTERNAL;
     }
 
-  stream->string_match  = smatcher->string_match;
-  XD3_ASSERT(stream->string_match);
-
-  XD3_COPY_CONFIG_FIELDS (stream, smatcher);
-
-  /* If it is a soft config, the smatcher fields didn't set anything, copy from config
-   * instead. */
-  if (stream->large_look == 0)
-    {
-      XD3_COPY_CONFIG_FIELDS (stream, config);
-    }
-
-  IF_DEBUG1 (P(RINT "[stream cfg] llook %u lstep %u slook %u\n",
-               stream->large_look, stream->large_step, stream->small_look));
   return 0;
 }
 
@@ -2638,7 +2614,7 @@ xd3_set_source (xd3_stream *stream,
 
   IF_DEBUG1 (P(RINT "[set source] size %"Q"u\n", src->size));
 
-  if (src == NULL || src->size < stream->large_look) { return 0; }
+  if (src == NULL || src->size < stream->smatcher.large_look) { return 0; }
 
   stream->src  = src;
   blk_num      = src->size / src->blksize;
@@ -3513,26 +3489,27 @@ xd3_encode_init (xd3_stream *stream)
   int i;
   int large_comp = (stream->src != NULL);
   int small_comp = ! (stream->flags & XD3_NOCOMPRESS);
-  /*int small_prev = (stream->small_chain > 1);*/
-  int space_fact = (large_comp + small_comp);
-  int memsize    = stream->memsize;
 
   /* Memory allocations for checksum tables are delayed until xd3_string_match_init in the
    * first call to string_match--that way identical or short inputs require no table
    * allocation. */
   if (large_comp)
     {
-      xd3_size_hashtable (stream, memsize / space_fact, & stream->large_hash);
+      xd3_size_hashtable (stream, stream->memsize, & stream->large_hash);
     }
 
   if (small_comp)
     {
-      xd3_size_hashtable (stream, memsize / space_fact, & stream->small_hash);
+      /* Keep table small because small matches become less efficient after long. */
+      xd3_size_hashtable (stream,
+                          min(stream->winsize, XD3_DEFAULT_MEMSIZE),
+                          & stream->small_hash);
     }
 
   for (i = 0; i < ENC_SECTS; i += 1)
     {
-      if ((stream->enc_heads[i] = stream->enc_tails[i] =
+      if ((stream->enc_heads[i] =
+           stream->enc_tails[i] =
            xd3_alloc_output (stream, NULL)) == NULL)
         {
           goto fail;
@@ -3735,7 +3712,7 @@ xd3_encode_input (xd3_stream *stream)
 
       /* String matching... */
       if (stream->avail_in != 0 &&
-          (ret = stream->string_match (stream)))
+          (ret = stream->smatcher.string_match (stream)))
         {
           return ret;
         }
@@ -3926,6 +3903,8 @@ xd3_string_match_init (xd3_stream *stream)
       if (stream->small_table != NULL)
         {
           /* The target hash table is reinitialized once per window. */
+          /* TODO: This would not have to be reinitialized if absolute offsets
+           * were being stored. */
           if (stream->small_reset)
             {
               stream->small_reset = 0;
@@ -3935,17 +3914,21 @@ 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 = xd3_alloc0 (stream,
+                                             stream->small_hash.size,
+                                             sizeof (usize_t))) == NULL)
         {
           return ENOMEM;
         }
 
       /* If there is a previous table needed. */
-      if (stream->small_chain > 1)
+      if (stream->smatcher.small_chain > 1)
         {
           xd3_slist *p, *m;
 
-          if ((stream->small_prev = xd3_alloc (stream, stream->sprevsz, sizeof (xd3_slist))) == NULL)
+          if ((stream->small_prev = xd3_alloc (stream,
+                                               stream->sprevsz,
+                                               sizeof (xd3_slist))) == NULL)
             {
               return ENOMEM;
             }
@@ -4026,7 +4009,7 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
       usize_t onblk = xd3_bytes_on_srcblk (stream->src, blkno);
       int ret;
 
-      if (blkoff + stream->large_look > onblk)
+      if (blkoff + stream->smatcher.large_look > onblk)
         {
           /* Next block */
           stream->srcwin_cksum_pos = (blkno + 1) * stream->src->blksize;
@@ -4042,19 +4025,19 @@ xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
           return ret;
         }
 
-      onblk -= stream->large_look;
+      onblk -= stream->smatcher.large_look;
       int diff = logical_input_cksum_pos - stream->srcwin_cksum_pos;
       onblk = min(blkoff + diff, onblk);
 
       while (blkoff <= onblk)
         {
-          uint32_t cksum = xd3_lcksum (stream->src->curblk + blkoff, stream->large_look);
+          uint32_t cksum = xd3_lcksum (stream->src->curblk + blkoff, stream->smatcher.large_look);
           usize_t hval = xd3_checksum_hash (& stream->large_hash, cksum);
 
           stream->large_table[hval] = stream->srcwin_cksum_pos + HASH_CKOFFSET;
 
-          blkoff += stream->large_step;
-          stream->srcwin_cksum_pos += stream->large_step;
+          blkoff += stream->smatcher.large_step;
+          stream->srcwin_cksum_pos += stream->smatcher.large_step;
 
           IF_DEBUG (stream->large_ckcnt += 1);
         }
@@ -4543,7 +4526,7 @@ xd3_check_smatch (const uint8_t *ref0, const uint8_t *inp0,
 /* When the hash table indicates a possible small string match, it calls this routine to
  * find the best match.  The first matching position is taken from the small_table,
  * HASH_CKOFFSET is subtracted to get the actual position.  After checking that match, if
- * previous linked lists are in use (because stream->small_chain > 1), previous matches
+ * previous linked lists are in use (because stream->smatcher.small_chain > 1), previous matches
  * are tested searching for the longest match.  If (stream->min_match > MIN_MATCH) then a lazy
  * match is in effect.
  *
@@ -4563,8 +4546,8 @@ xd3_smatch (xd3_stream *stream, usize_t base, usize_t scksum, usize_t *match_off
   usize_t         cmp_len;
   usize_t         match_length = 0;
   usize_t         chain        = (stream->min_match == MIN_MATCH ?
-                                  stream->small_chain :
-                                  stream->small_lchain);
+                                  stream->smatcher.small_chain :
+                                  stream->smatcher.small_lchain);
   xd3_slist     *current      = NULL;
   xd3_slist     *first        = NULL;
   const uint8_t *inp_max      = stream->next_in + stream->avail_in;
@@ -4621,7 +4604,7 @@ xd3_smatch (xd3_stream *stream, usize_t base, usize_t scksum, usize_t *match_off
       (*match_offset) = base;
 
       /* Stop if we match the entire input or discover a long_enough match. */
-      if (inp == inp_max || cmp_len >= stream->long_enough)
+      if (inp == inp_max || cmp_len >= stream->smatcher.long_enough)
         {
           goto done;
         }
@@ -4661,7 +4644,7 @@ xd3_verify_small_state (xd3_stream    *stream,
                         const uint8_t *inp,
                         uint32_t          x_cksum)
 {
-  uint32_t cksum = xd3_scksum (inp, stream->small_look);
+  uint32_t cksum = xd3_scksum (inp, stream->smatcher.small_look);
 
   XD3_ASSERT (cksum == x_cksum);
 }
@@ -4671,7 +4654,7 @@ xd3_verify_large_state (xd3_stream    *stream,
                         const uint8_t *inp,
                         uint32_t          x_cksum)
 {
-  uint32_t cksum = xd3_lcksum (inp, stream->large_look);
+  uint32_t cksum = xd3_lcksum (inp, stream->smatcher.large_look);
 
   XD3_ASSERT (cksum == x_cksum);
 }
@@ -4682,7 +4665,7 @@ xd3_verify_run_state (xd3_stream    *stream,
                       int            x_run_l,
                       uint8_t        x_run_c)
 {
-  int     slook = stream->small_look;
+  int     slook = stream->smatcher.small_look;
   uint8_t run_c;
   int     run_l = xd3_comprun (inp, slook, &run_c);
 
diff --git a/xdelta3/xdelta3.h b/xdelta3/xdelta3.h
index b538d77..90b2fd9 100755
--- a/xdelta3/xdelta3.h
+++ b/xdelta3/xdelta3.h
@@ -38,21 +38,9 @@
 #define XD3_DEFAULT_WINSIZE (1U << 18)
 #endif
 
-/* The source block size.
- */
-#ifndef XD3_DEFAULT_SRCBLKSZ
-#define XD3_DEFAULT_SRCBLKSZ (1U << 18)
-#endif
-
-/* The source window starts with only a few checksums, then doubles up to
- * XD3_DEFAULT_MAX_CKSUM_ADVANCE. */
-#ifndef XD3_DEFAULT_START_CKSUM_ADVANCE
-#define XD3_DEFAULT_START_CKSUM_ADVANCE (1U << 14)
-#endif
-
-/* TODO: There is no command-line flag to set this value. */
-#ifndef XD3_DEFAULT_MAX_CKSUM_ADVANCE
-#define XD3_DEFAULT_MAX_CKSUM_ADVANCE (1U << 23)
+/* This is a unit of how far to advance the checksum position in one go. */
+#ifndef XD3_DEFAULT_CKSUM_ADVANCE
+#define XD3_DEFAULT_CKSUM_ADVANCE (1U << 14)
 #endif
 
 /* Default total size of the source window used in xdelta3-main.h */
@@ -69,7 +57,7 @@
 /* When Xdelta requests a memory allocation for certain buffers, it rounds up to units of
  * at least this size.  The code assumes (and asserts) that this is a power-of-two. */
 #ifndef XD3_ALLOCSIZE
-#define XD3_ALLOCSIZE (1U<<13)
+#define XD3_ALLOCSIZE (1U<<14)
 #endif
 
 /* The XD3_HARDMAXWINSIZE parameter is a safety mechanism to protect decoders against
@@ -506,9 +494,7 @@ struct _xd3_iopt_buf
   xd3_rinst *buffer;
 };
 
-/* This is the record of a pre-compiled configuration, a subset of xd3_config.  Keep them
- * in sync!  The user never sees this structure.  Note: update XD3_SOFTCFG_VARCNT when
- * changing. */
+/* This is the record of a pre-compiled configuration, a subset of xd3_config. */
 struct _xd3_smatcher
 {
   const char        *name;
@@ -577,7 +563,6 @@ struct _xd3_config
   usize_t             winsize;       /* The encoder window size. */
   usize_t             sprevsz;       /* How far back small string matching goes */
   usize_t             iopt_size;     /* entries in the instruction-optimizing buffer */
-
   usize_t             srcwin_size;   /* Initial size of the source-window lookahead */
   usize_t             srcwin_maxsz;  /* srcwin_size grows by a factor of 2 when no matches are found */
 
@@ -594,16 +579,7 @@ struct _xd3_config
   xd3_sec_cfg       sec_addr;       /* Secondary compressor config: addr */
 
   xd3_smatch_cfg     smatch_cfg;    /* See enum: use fields below for soft config */
-  uint               large_look;    /* large string lookahead (i.e., hashed chars) */
-  uint               large_step;    /* large string interval */
-  uint               small_look;    /* small string lookahead (i.e., hashed chars) */
-  uint               small_chain;   /* small string number of previous matches to try */
-  uint               small_lchain;  /* small string number of previous matches to try, when a lazy match */
-  uint               ssmatch;       /* boolean: insert checksums for matched strings */
-  uint               try_lazy;      /* boolean: whether lazy instruction optimization is attempted */
-  uint               max_lazy;      /* size of smallest match that will disable lazy matching */
-  uint               long_enough;   /* size of smallest match long enough to discontinue string matching. */
-  uint               promote;       /* whether to promote matches in the hash chain */
+  xd3_smatcher       smatcher_soft;
 };
 
 /* The primary source file object. You create one of these objects and initialize the
@@ -661,6 +637,8 @@ struct _xd3_stream
   usize_t           sprevsz;          /* small string, previous window size (power of 2) */
   usize_t           sprevmask;        /* small string, previous window size mask */
   uint              iopt_size;
+  uint              srcwin_size;
+  uint              srcwin_maxsz;
 
   /* general configuration */
   xd3_getblk_func  *getblk;           /* set nxtblk, nxtblkno to scanblkno */
@@ -668,40 +646,24 @@ struct _xd3_stream
   xd3_free_func    *free;             /* free function */
   void*             opaque;           /* private data object passed to alloc, free, and getblk */
   int               flags;            /* various options */
-  int               aborted;
   
   /* secondary compressor configuration */
   xd3_sec_cfg       sec_data;         /* Secondary compressor config: data */
   xd3_sec_cfg       sec_inst;         /* Secondary compressor config: inst */
   xd3_sec_cfg       sec_addr;         /* Secondary compressor config: addr */
 
-  /* fields common to xd3_stream_config, xd3_smatcher */
-  uint              large_look;
-  uint              large_step;
-  uint              small_look;
-  uint              small_chain;
-  uint              small_lchain;
-  uint              ssmatch;
-  uint              try_lazy;
-  uint              max_lazy;
-  uint              long_enough;
-  uint              promote;
-  uint              srcwin_size;
-  uint              srcwin_maxsz;
-  int             (*string_match) (xd3_stream  *stream);
+  xd3_smatcher      smatcher;
 
   usize_t           *large_table;      /* table of large checksums */
-  xd3_hash_cfg      large_hash;       /* large hash config */
+  xd3_hash_cfg       large_hash;       /* large hash config */
 
   usize_t           *small_table;      /* table of small checksums */
-  xd3_slist        *small_prev;       /* table of previous offsets, circular linked list (no sentinel) */
-  int               small_reset;      /* true if small table should be reset */
-
-  xd3_hash_cfg      small_hash;       /* small hash config */
-
-  xd3_addr_cache    acache;           /* the vcdiff address cache */
+  xd3_slist         *small_prev;       /* table of previous offsets, circular linked list */
+  int                small_reset;      /* true if small table should be reset */
 
-  xd3_encode_state  enc_state;        /* state of the encoder */
+  xd3_hash_cfg       small_hash;       /* small hash config */
+  xd3_addr_cache     acache;           /* the vcdiff address cache */
+  xd3_encode_state   enc_state;        /* state of the encoder */
 
   usize_t            taroff;           /* base offset of the target input */
   usize_t            input_position;   /* current input position */