working on inline functions

5 files changed, 153 insertions, 154 deletions

diff --git a/xdelta3/Makefile b/xdelta3/Makefile
index 17fd314..8ce2113 100644
--- a/xdelta3/Makefile
+++ b/xdelta3/Makefile
@@ -104,6 +104,8 @@ wix: xdelta3.wxs xdelta3.wxi readme.txt Release\xdelta3.exe
         $(WIXDIR)/candle.exe xdelta3.wxs -out xdelta3.wixobj
         $(WIXDIR)/light.exe xdelta3.wixobj -out xdelta3.msi
 
+CC=gcc-4.2.0
+
 xdelta3: $(SOURCES)
         $(CC) -O3 -Wall -Wshadow xdelta3.c -lm -o xdelta3 \
               -DXD3_DEBUG=0 \
diff --git a/xdelta3/releases/xdelta30r.tar.gz b/xdelta3/releases/xdelta30r.tar.gz
new file mode 100755
index 0000000..e1bba34
--- /dev/null
+++ b/xdelta3/releases/xdelta30r.tar.gz
diff --git a/xdelta3/xdelta3-main.h b/xdelta3/xdelta3-main.h
index c02be63..7f75c98 100644
--- a/xdelta3/xdelta3-main.h
+++ b/xdelta3/xdelta3-main.h
@@ -1370,11 +1370,11 @@ static char* ext_tmpfile = NULL;
 
 /* Like write(), but makes repeated calls to empty the buffer. */
 static int
-main_pipe_write (int outfd, const uint8_t *exist_buf, usize_t remain)
+main_pipe_write (int outfd, uint8_t *exist_buf, usize_t remain)
 {
   int ret;
 
-  if ((ret = xd3_posix_io (outfd, (uint8_t*) exist_buf, remain, (xd3_posix_func*) &write, NULL)))
+  if ((ret = xd3_posix_io (outfd, exist_buf, remain, (xd3_posix_func*) &write, NULL)))
     {
       XPR(NT "pipe write failed: %s", xd3_mainerror (ret));
       return ret;
@@ -3420,10 +3420,13 @@ main (int argc, char **argv)
 static int
 main_help (void)
 {
-  /* TODO: license info */
+  /* $Format: "  DP(RINT \"Xdelta version $Xdelta3Version$, Copyright (C) 2007, Joshua MacDonald\n\");" $ */
+
+  DP(RINT "Xdelta comes with ABSOLUTELY NO WARRANTY.\n");
+  DP(RINT "This is free software, and you are welcome to redistribute it\n");
+  DP(RINT "under certain conditions; see \"COPYING\" for details.\n");
 
   /* Note: update wiki when command-line features change */
-  main_version ();
   DP(RINT "usage: xdelta3 [command/options] [input [output]]\n");
   DP(RINT "special command names:\n");
   DP(RINT "    config      prints xdelta3 configuration\n");
@@ -3465,13 +3468,8 @@ main_help (void)
   DP(RINT "   -n           disable checksum (encode/decode)\n");
   DP(RINT "   -C           soft config (encode, undocumented)\n");
   DP(RINT "   -A [apphead] disable/provide application header (encode)\n");
-
-#if XD3_DEBUG > 0
-  DP(RINT "developer options:\n");
   DP(RINT "   -J           disable output (check/compute only)\n");
-  DP(RINT "   -P           repeat count (for profiling)\n");
-  DP(RINT "   -T           use alternate code table\n");
-#endif
+  DP(RINT "   -T           use alternate code table (test)\n");
 
   DP(RINT "the XDELTA environment variable may contain extra args:\n");
   DP(RINT "   XDELTA=\"-s source-x.y.tar.gz\" \\\n");
@@ -3479,4 +3477,3 @@ main_help (void)
   DP(RINT "       -cf target-x.z.tar.gz.vcdiff target-x.y/\n");
   return EXIT_FAILURE;
 }
-
diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index a545b66..fc0b780 100644
--- a/xdelta3/xdelta3.c
+++ b/xdelta3/xdelta3.c
@@ -4199,145 +4199,6 @@ xd3_srcwin_setup (xd3_stream *stream)
   return 0;
 }
 
-/* This function computes more source checksums to advance the window.
- * Called at every entrance to the string-match loop and each time
- * stream->input_position reaches the value returned as
- * *next_move_point.  NB: this is one of the most expensive functions
- * in this code and also the most critical for good compression.
- *
- * TODO: really would like a good test for this logic. how?
- * TODO: optimize the inner loop
- */
-static int
-xd3_srcwin_move_point (xd3_stream *stream, usize_t *next_move_point)
-{
-  xoff_t logical_input_cksum_pos;
-
-  XD3_ASSERT(stream->srcwin_cksum_pos <= stream->src->size);
-  if (stream->srcwin_cksum_pos == stream->src->size)
-    {
-      *next_move_point = USIZE_T_MAX;
-      return 0;
-    }
-
-  /* Begin by advancing at twice the input rate, up to half the
-   * maximum window size. */
-  logical_input_cksum_pos = min((stream->total_in + stream->input_position) * 2,
-                                (stream->total_in + stream->input_position) +
-                                  (stream->srcwin_maxsz / 2));
-
-  /* If srcwin_cksum_pos is already greater, wait until the difference
-   * is met. */
-  if (stream->srcwin_cksum_pos > logical_input_cksum_pos)
-    {
-      *next_move_point = stream->input_position +
-        (usize_t)(stream->srcwin_cksum_pos - logical_input_cksum_pos);
-      return 0;
-    }
-
-  /* A long match may have extended past srcwin_cksum_pos.  Don't
-   * start checksumming already-matched source data. */
-  if (stream->maxsrcaddr > stream->srcwin_cksum_pos)
-    {
-      stream->srcwin_cksum_pos = stream->maxsrcaddr;
-    }
-
-  if (logical_input_cksum_pos < stream->srcwin_cksum_pos)
-    {
-      logical_input_cksum_pos = stream->srcwin_cksum_pos;
-    }
-
-  /* Advance at least one source block.  With the command-line
-   * defaults this means:
-   *
-   * if (src->size <= srcwin_maxsz), index the entire source at once
-   * using the position of the first non-match.  This is good for
-   * small inputs, especially when the content may have moved anywhere
-   * in the file (e.g., tar files).
-   *
-   * if (src->size > srcwin_maxsz), index at least one block (which
-   * the command-line sets to 1/32 of srcwin_maxsz) ahead of the
-   * logical position.  This is good for different reasons: when a
-   * long match spanning several source blocks is encountered, this
-   * avoids computing checksums for those blocks.  If the data can
-   * move anywhere, this is bad.
-   */
-  logical_input_cksum_pos += stream->src->blksize;
-
-  IF_DEBUG1 (DP(RINT "[srcwin_move_point] T=%"Q"u S=%"Q"u/%"Q"u\n",
-               stream->total_in + stream->input_position,
-               stream->srcwin_cksum_pos,
-               logical_input_cksum_pos));
-
-  while (stream->srcwin_cksum_pos < logical_input_cksum_pos &&
-         stream->srcwin_cksum_pos < stream->src->size)
-    {
-      xoff_t  blkno = stream->srcwin_cksum_pos / stream->src->blksize;
-      ssize_t oldpos = stream->srcwin_cksum_pos % stream->src->blksize;
-      ssize_t blkpos = xd3_bytes_on_srcblk (stream->src, blkno);
-      int ret;
-
-      if (oldpos + stream->smatcher.large_look > blkpos)
-        {
-          stream->srcwin_cksum_pos = (blkno + 1) * stream->src->blksize;
-          continue;
-        }
-
-      if ((ret = xd3_getblk (stream, blkno)))
-        {
-          /* TOOFARBACK should never occur here, since we read forward. */
-          if (ret == XD3_TOOFARBACK)
-            {
-              ret = XD3_INTERNAL;
-            }
-          return ret;
-        }
-
-      /* This inserts checksums for the entire block, in reverse,
-       * starting from the end of the block.  This logic does not test
-       * stream->srcwin_cksum_pos because it always advances it to the
-       * start of the next block.
-       *
-       * oldpos is the srcwin_cksum_pos within this block.  blkpos is
-       * the number of bytes available.  Each iteration inspects
-       * large_look bytes then steps back large_step bytes.  The
-       * if-stmt above ensures at least one large_look of data. */
-      blkpos -= stream->smatcher.large_look;
-
-      do
-        {
-          uint32_t cksum = xd3_lcksum (stream->src->curblk + blkpos,
-                                       stream->smatcher.large_look);
-          usize_t hval = xd3_checksum_hash (& stream->large_hash, cksum);
-
-          stream->large_table[hval] =
-            (usize_t) ((stream->src->blksize * blkno) +
-                       (xoff_t)(blkpos + HASH_CKOFFSET));
-
-          IF_DEBUG (stream->large_ckcnt += 1);
-
-          blkpos -= stream->smatcher.large_step;
-        }
-      while (blkpos >= oldpos);
-
-      stream->srcwin_cksum_pos = (blkno + 1) * stream->src->blksize;
-    }
-
-  if (stream->srcwin_cksum_pos >= stream->src->size)
-    {
-      /* This invariant is needed for xd3_source_cksum_offset() */
-      stream->srcwin_cksum_pos = stream->src->size;
-      *next_move_point = USIZE_T_MAX;
-      return 0;
-    }
-
-  /* How long until this function should be called again. */
-  XD3_ASSERT(stream->srcwin_cksum_pos >= logical_input_cksum_pos);
-  *next_move_point = stream->input_position + 1 +
-    (usize_t)(stream->srcwin_cksum_pos - logical_input_cksum_pos);
-  return 0;
-}
-
 /* Sets the bounding region for a newly discovered source match, prior to calling
  * xd3_source_extend_match().  This sets the match_maxfwd, match_maxback variables.  Note:
  * srcpos is an absolute position (xoff_t) but the match_maxfwd, match_maxback variables
@@ -4848,6 +4709,145 @@ static const xd3_smatcher XD3_TEMPLATE(__smatcher_) =
 #endif
 };
 
+/* This function computes more source checksums to advance the window.
+ * Called at every entrance to the string-match loop and each time
+ * stream->input_position reaches the value returned as
+ * *next_move_point.  NB: this is one of the most expensive functions
+ * in this code and also the most critical for good compression.
+ *
+ * TODO: really would like a good test for this logic. how?
+ * TODO: optimize the inner loop
+ */
+static int
+XD3_TEMPLATE(xd3_srcwin_move_point_) (xd3_stream *stream, usize_t *next_move_point)
+{
+  xoff_t logical_input_cksum_pos;
+
+  XD3_ASSERT(stream->srcwin_cksum_pos <= stream->src->size);
+  if (stream->srcwin_cksum_pos == stream->src->size)
+    {
+      *next_move_point = USIZE_T_MAX;
+      return 0;
+    }
+
+  /* Begin by advancing at twice the input rate, up to half the
+   * maximum window size. */
+  logical_input_cksum_pos = min((stream->total_in + stream->input_position) * 2,
+                                (stream->total_in + stream->input_position) +
+                                  (stream->srcwin_maxsz / 2));
+
+  /* If srcwin_cksum_pos is already greater, wait until the difference
+   * is met. */
+  if (stream->srcwin_cksum_pos > logical_input_cksum_pos)
+    {
+      *next_move_point = stream->input_position +
+        (usize_t)(stream->srcwin_cksum_pos - logical_input_cksum_pos);
+      return 0;
+    }
+
+  /* A long match may have extended past srcwin_cksum_pos.  Don't
+   * start checksumming already-matched source data. */
+  if (stream->maxsrcaddr > stream->srcwin_cksum_pos)
+    {
+      stream->srcwin_cksum_pos = stream->maxsrcaddr;
+    }
+
+  if (logical_input_cksum_pos < stream->srcwin_cksum_pos)
+    {
+      logical_input_cksum_pos = stream->srcwin_cksum_pos;
+    }
+
+  /* Advance at least one source block.  With the command-line
+   * defaults this means:
+   *
+   * if (src->size <= srcwin_maxsz), index the entire source at once
+   * using the position of the first non-match.  This is good for
+   * small inputs, especially when the content may have moved anywhere
+   * in the file (e.g., tar files).
+   *
+   * if (src->size > srcwin_maxsz), index at least one block (which
+   * the command-line sets to 1/32 of srcwin_maxsz) ahead of the
+   * logical position.  This is good for different reasons: when a
+   * long match spanning several source blocks is encountered, this
+   * avoids computing checksums for those blocks.  If the data can
+   * move anywhere, this is bad.
+   */
+  logical_input_cksum_pos += stream->src->blksize;
+
+  IF_DEBUG1 (DP(RINT "[srcwin_move_point] T=%"Q"u S=%"Q"u/%"Q"u\n",
+               stream->total_in + stream->input_position,
+               stream->srcwin_cksum_pos,
+               logical_input_cksum_pos));
+
+  while (stream->srcwin_cksum_pos < logical_input_cksum_pos &&
+         stream->srcwin_cksum_pos < stream->src->size)
+    {
+      xoff_t  blkno = stream->srcwin_cksum_pos / stream->src->blksize;
+      ssize_t oldpos = stream->srcwin_cksum_pos % stream->src->blksize;
+      ssize_t blkpos = xd3_bytes_on_srcblk (stream->src, blkno);
+      int ret;
+
+      if (oldpos + stream->smatcher.large_look > blkpos)
+        {
+          stream->srcwin_cksum_pos = (blkno + 1) * stream->src->blksize;
+          continue;
+        }
+
+      if ((ret = xd3_getblk (stream, blkno)))
+        {
+          /* TOOFARBACK should never occur here, since we read forward. */
+          if (ret == XD3_TOOFARBACK)
+            {
+              ret = XD3_INTERNAL;
+            }
+          return ret;
+        }
+
+      /* This inserts checksums for the entire block, in reverse,
+       * starting from the end of the block.  This logic does not test
+       * stream->srcwin_cksum_pos because it always advances it to the
+       * start of the next block.
+       *
+       * oldpos is the srcwin_cksum_pos within this block.  blkpos is
+       * the number of bytes available.  Each iteration inspects
+       * large_look bytes then steps back large_step bytes.  The
+       * if-stmt above ensures at least one large_look of data. */
+      blkpos -= stream->smatcher.large_look;
+
+      do
+        {
+          uint32_t cksum = xd3_lcksum (stream->src->curblk + blkpos,
+                                       stream->smatcher.large_look);
+          usize_t hval = xd3_checksum_hash (& stream->large_hash, cksum);
+
+          stream->large_table[hval] =
+            (usize_t) ((stream->src->blksize * blkno) +
+                       (xoff_t)(blkpos + HASH_CKOFFSET));
+
+          IF_DEBUG (stream->large_ckcnt += 1);
+
+          blkpos -= stream->smatcher.large_step;
+        }
+      while (blkpos >= oldpos);
+
+      stream->srcwin_cksum_pos = (blkno + 1) * stream->src->blksize;
+    }
+
+  if (stream->srcwin_cksum_pos >= stream->src->size)
+    {
+      /* This invariant is needed for xd3_source_cksum_offset() */
+      stream->srcwin_cksum_pos = stream->src->size;
+      *next_move_point = USIZE_T_MAX;
+      return 0;
+    }
+
+  /* How long until this function should be called again. */
+  XD3_ASSERT(stream->srcwin_cksum_pos >= logical_input_cksum_pos);
+  *next_move_point = stream->input_position + 1 +
+    (usize_t)(stream->srcwin_cksum_pos - logical_input_cksum_pos);
+  return 0;
+}
+
 static int
 XD3_TEMPLATE(xd3_string_match_) (xd3_stream *stream)
 {
@@ -4866,7 +4866,7 @@ XD3_TEMPLATE(xd3_string_match_) (xd3_stream *stream)
   int            run_l;
   int            ret;
   usize_t         match_length;
-  usize_t         match_offset;  /* "may be unused" warnings are bogus (due to min_match test) */
+  usize_t         match_offset = 0;
   usize_t         next_move_point;
 
   /* If there will be no compression due to settings or short input, skip it entirely. */
@@ -4917,7 +4917,7 @@ XD3_TEMPLATE(xd3_string_match_) (xd3_stream *stream)
     {
       /* Source window: next_move_point is the point that stream->input_position must reach before
        * computing more source checksum. */
-      if ((ret = xd3_srcwin_move_point (stream, & next_move_point)))
+      if ((ret = XD3_TEMPLATE(xd3_srcwin_move_point_) (stream, & next_move_point)))
         {
           return ret;
         }
@@ -4973,7 +4973,7 @@ XD3_TEMPLATE(xd3_string_match_) (xd3_stream *stream)
       if (DO_LARGE && (stream->input_position + LLOOK <= stream->avail_in))
         {
           if ((stream->input_position >= next_move_point) &&
-              (ret = xd3_srcwin_move_point (stream, & next_move_point)))
+              (ret = XD3_TEMPLATE(xd3_srcwin_move_point_) (stream, & next_move_point)))
             {
               return ret;
             }
diff --git a/xdelta3/xdelta3.prj b/xdelta3/xdelta3.prj
index de7b70a..7bcb904 100644
--- a/xdelta3/xdelta3.prj
+++ b/xdelta3/xdelta3.prj
@@ -9,7 +9,7 @@
 (Checkin-Login jmacd)
 (Populate-Ignore ("\\.svn"))
 (Project-Keywords
- (Xdelta3Version "0r")
+ (Xdelta3Version "3.0r")
  )
 (Files
   (COPYING (xdelta3/b/29_COPYING 1.1 744))