5 files changed, 83 insertions, 67 deletions

diff --git a/xdelta3/xdelta3-djw.h b/xdelta3/xdelta3-djw.h
index 396f73c..a9f6e6f 100644
--- a/xdelta3/xdelta3-djw.h
+++ b/xdelta3/xdelta3-djw.h
@@ -16,15 +16,15 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-/* TODO: This code needs a thorough round of commenting.  There is some slop in the
- * declaration of arrays, which are maybe one element larger than they need to be and
- * comments would help clear it up. */
+/* TODO: This code needs a thorough round of commenting.  There is
+ * some slop in the declaration of arrays, which are maybe one element
+ * larger than they need to be and comments would help clear it up. */
 
 #ifndef _XDELTA3_DJW_H_
 #define _XDELTA3_DJW_H_
 
-/* The following people deserve much credit for the algorithms and techniques contained in
- * this file:
+/* The following people deserve much credit for the algorithms and
+ * techniques contained in this file:
 
  Julian Seward
  Bzip2 sources, implementation of the multi-table Huffman technique.
@@ -43,13 +43,14 @@
 
 */
 
-/* OPT: during the multi-table iteration, pick the worst-overall performing table and
- * replace it with exactly the frequencies of the worst-overall performing sector or
- * N-worst performing sectors. */
+/* OPT: during the multi-table iteration, pick the worst-overall
+ * performing table and replace it with exactly the frequencies of the
+ * worst-overall performing sector or N-worst performing sectors. */
 
-/* REF: See xdfs-0.222 and xdfs-0.226 for some old experiments with the Bzip prefix coding
- * strategy.  xdfs-0.256 contains the last of the other-format tests, including RFC1950
- * and the RFC1950+MTF tests. */
+/* REF: See xdfs-0.222 and xdfs-0.226 for some old experiments with
+ * the Bzip prefix coding strategy.  xdfs-0.256 contains the last of
+ * the other-format tests, including RFC1950 and the RFC1950+MTF
+ * tests. */
 
 #define DJW_MAX_CODELEN      20 /* Maximum length of an alphabet code. */
 
@@ -111,27 +112,31 @@ struct _djw_stream
   int unused;
 };
 
-/* Each Huffman table consists of 256 "code length" (CLEN) codes, which are themselves
- * Huffman coded after eliminating repeats and move-to-front coding.  The prefix consists
- * of all the CLEN codes in djw_encode_basic plus a 4-bit value stating how many of the
- * djw_encode_extra codes are actually coded (the rest are presumed zero, or unused CLEN
- * codes).
+/* Each Huffman table consists of 256 "code length" (CLEN) codes,
+ * which are themselves Huffman coded after eliminating repeats and
+ * move-to-front coding.  The prefix consists of all the CLEN codes in
+ * djw_encode_basic plus a 4-bit value stating how many of the
+ * djw_encode_extra codes are actually coded (the rest are presumed
+ * zero, or unused CLEN codes).
  *
- * These values of these two arrays were arrived at by studying the distribution of min
- * and max clen over a collection of DATA, INST, and ADDR inputs.  The goal is to specify
- * the order of djw_extra_codes that is most likely to minimize the number of extra codes
- * that must be encoded.
+ * These values of these two arrays were arrived at by studying the
+ * distribution of min and max clen over a collection of DATA, INST,
+ * and ADDR inputs.  The goal is to specify the order of
+ * djw_extra_codes that is most likely to minimize the number of extra
+ * codes that must be encoded.
  *
- * Results: 158896 sections were counted by compressing files (window size 512K) listed
- * with: `find / -type f ( -user jmacd -o -perm +444 )`
+ * Results: 158896 sections were counted by compressing files (window
+ * size 512K) listed with: `find / -type f ( -user jmacd -o -perm +444
+ * )`
  *
- * The distribution of CLEN codes for each efficient invocation of the secondary
- * compressor (taking the best number of groups/sector size) was recorded.  Then we look at
- * the distribution of min and max clen values, counting the number of times the value
- * C_low is less than the min and C_high is greater than the max.  Values >= C_high and <=
- * C_low will not have their lengths coded.  The results are sorted and the least likely
- * 15 are placed into the djw_encode_extra[] array in order.  These values are used as
- * the initial MTF ordering.
+ * The distribution of CLEN codes for each efficient invocation of the
+ * secondary compressor (taking the best number of groups/sector size)
+ * was recorded.  Then we look at the distribution of min and max clen
+ * values, counting the number of times the value C_low is less than
+ * the min and C_high is greater than the max.  Values >= C_high and
+ * <= C_low will not have their lengths coded.  The results are sorted
+ * and the least likely 15 are placed into the djw_encode_extra[]
+ * array in order.  These values are used as the initial MTF ordering.
 
  clow[1] = 155119
  clow[2] = 140325
diff --git a/xdelta3/xdelta3-fgk.h b/xdelta3/xdelta3-fgk.h
index f5d8fc6..b2b8f09 100644
--- a/xdelta3/xdelta3-fgk.h
+++ b/xdelta3/xdelta3-fgk.h
@@ -22,11 +22,12 @@
 #ifndef _XDELTA3_FGK_h_
 #define _XDELTA3_FGK_h_
 
-/* An implementation of the FGK algorithm described by D.E. Knuth in "Dynamic Huffman
- * Coding" in Journal of Algorithms 6. */
+/* An implementation of the FGK algorithm described by D.E. Knuth in
+ * "Dynamic Huffman Coding" in Journal of Algorithms 6. */
 
-/* A 32bit counter (fgk_weight) is used as the frequency counter for nodes in the huffman
- * tree.  TODO: Need to test for overflow and/or reset stats. */
+/* A 32bit counter (fgk_weight) is used as the frequency counter for
+ * nodes in the huffman tree.  TODO: Need oto test for overflow and/or
+ * reset stats. */
 
 typedef struct _fgk_stream fgk_stream;
 typedef struct _fgk_node   fgk_node;
@@ -47,12 +48,14 @@ struct _fgk_block {
 /* The code can also support fixed huffman encoding/decoding. */
 #define IS_ADAPTIVE 1
 
-/* weight is a count of the number of times this element has been seen in the current
- * encoding/decoding.  parent, right_child, and left_child are pointers defining the tree
- * structure.  right and left point to neighbors in an ordered sequence of
- * weights.  The left child of a node is always guaranteed to have weight not greater than
- * its sibling.  fgk_blockLeader points to the element with the same weight as itself which is
- * closest to the next increasing weight block.  */
+/* weight is a count of the number of times this element has been seen
+ * in the current encoding/decoding.  parent, right_child, and
+ * left_child are pointers defining the tree structure.  right and
+ * left point to neighbors in an ordered sequence of weights.  The
+ * left child of a node is always guaranteed to have weight not
+ * greater than its sibling.  fgk_blockLeader points to the element
+ * with the same weight as itself which is closest to the next
+ * increasing weight block.  */
 struct _fgk_node
 {
   fgk_weight  weight;
@@ -64,14 +67,17 @@ struct _fgk_node
   fgk_block  *my_block;
 };
 
-/* alphabet_size is the a count of the number of possible leaves in the huffman tree.  The
- * number of total nodes counting internal nodes is ((2 * alphabet_size) - 1).
- * zero_freq_count is the number of elements remaining which have zero frequency.
- * zero_freq_exp and zero_freq_rem satisfy the equation zero_freq_count = 2^zero_freq_exp +
- * zero_freq_rem.  root_node is the root of the tree, which is initialized to a node with
- * zero frequency and contains the 0th such element.  free_node contains a pointer to the
- * next available fgk_node space.  alphabet contains all the elements and is indexed by N.
- * remaining_zeros points to the head of the list of zeros.  */
+/* alphabet_size is the a count of the number of possible leaves in
+ * the huffman tree.  The number of total nodes counting internal
+ * nodes is ((2 * alphabet_size) - 1).  zero_freq_count is the number
+ * of elements remaining which have zero frequency.  zero_freq_exp and
+ * zero_freq_rem satisfy the equation zero_freq_count =
+ * 2^zero_freq_exp + zero_freq_rem.  root_node is the root of the
+ * tree, which is initialized to a node with zero frequency and
+ * contains the 0th such element.  free_node contains a pointer to the
+ * next available fgk_node space.  alphabet contains all the elements
+ * and is indexed by N.  remaining_zeros points to the head of the
+ * list of zeros.  */
 struct _fgk_stream
 {
   int alphabet_size;
@@ -533,9 +539,10 @@ static fgk_node* fgk_increase_zero_weight (fgk_stream *h, int n)
   return this_zero;
 }
 
-/* When a zero frequency element is encoded, it is followed by the binary representation
- * of the index into the remaining elements.  Sets a cache to the element before it so
- * that it can be removed without calling this procedure again.  */
+/* When a zero frequency element is encoded, it is followed by the
+ * binary representation of the index into the remaining elements.
+ * Sets a cache to the element before it so that it can be removed
+ * without calling this procedure again.  */
 static unsigned int fgk_find_nth_zero (fgk_stream* h, int n)
 {
   fgk_node *target_ptr = h->alphabet + n;
@@ -604,9 +611,10 @@ static void fgk_init_node (fgk_node *node, int i, int size)
   node->my_block    = NULL;
 }
 
-/* The data structure used is an array of blocks, which are unions of free pointers and
- * huffnode pointers.  free blocks are a linked list of free blocks, the front of which is
- * h->free_block.  The used blocks are pointers to the head of each block.  */
+/* The data structure used is an array of blocks, which are unions of
+ * free pointers and huffnode pointers.  free blocks are a linked list
+ * of free blocks, the front of which is h->free_block.  The used
+ * blocks are pointers to the head of each block.  */
 static fgk_block* fgk_make_block (fgk_stream *h, fgk_node* lead)
 {
   fgk_block *ret = h->free_block;
@@ -627,8 +635,8 @@ static void fgk_free_block (fgk_stream *h, fgk_block *b)
   h->free_block = b;
 }
 
-/* sets zero_freq_count, zero_freq_rem, and zero_freq_exp to satsity the equation given
- * above.  */
+/* sets zero_freq_count, zero_freq_rem, and zero_freq_exp to satsity
+ * the equation given above.  */
 static void fgk_factor_remaining (fgk_stream *h)
 {
   unsigned int i;
@@ -705,9 +713,10 @@ static int fgk_nth_zero (fgk_stream* h, int n)
 {
   fgk_node *ret = h->remaining_zeros;
 
-  /* ERROR: if during this loop (ret->right_child == NULL) then the encoder's zero count
-   * is too high.  Could return an error code now, but is probably unnecessary overhead,
-   * since the caller should check integrity anyway. */
+  /* ERROR: if during this loop (ret->right_child == NULL) then the
+   * encoder's zero count is too high.  Could return an error code
+   * now, but is probably unnecessary overhead, since the caller
+   * should check integrity anyway. */
   for (; n != 0 && ret->right_child != NULL; n -= 1)
     {
       ret = ret->right_child;
diff --git a/xdelta3/xdelta3-main.h b/xdelta3/xdelta3-main.h
index 0c5e08d..4d642df 100644
--- a/xdelta3/xdelta3-main.h
+++ b/xdelta3/xdelta3-main.h
@@ -2955,10 +2955,11 @@ done:
   main_file_close (ifile);
   main_file_close (sfile);
 
-  /* If output file is not open yet because of delayed-open, it means we never encountered
-   * a window in the delta, but it could have had a VCDIFF header?  TODO: solve this
-   * elsewhere.  For now, it prints "nothing to output" below, but the check doesn't
-   * happen in case of option_no_output.  */
+  /* If output file is not open yet because of delayed-open, it means
+   * we never encountered a window in the delta, but it could have had
+   * a VCDIFF header?  TODO: solve this elsewhere.  For now, it prints
+   * "nothing to output" below, but the check doesn't happen in case
+   * of option_no_output.  */
   if (! option_no_output)
     {
       if (!stdout_only && ! main_file_isopen (ofile))
diff --git a/xdelta3/xdelta3-test.h b/xdelta3/xdelta3-test.h
index f4fb76f..0739e2d 100644
--- a/xdelta3/xdelta3-test.h
+++ b/xdelta3/xdelta3-test.h
@@ -2339,10 +2339,10 @@ xd3_selftest (void)
   DO_TEST (decompress_single_bit_error, XD3_ADLER32, 3);
 
   IF_FGK (DO_TEST (decompress_single_bit_error, XD3_SEC_FGK, 3));
-  IF_DJW (DO_TEST (decompress_single_bit_error, XD3_SEC_DJW, 17));
+  IF_DJW (DO_TEST (decompress_single_bit_error, XD3_SEC_DJW, 18));
 
-  /* There are many expected non-failures for ALT_CODE_TABLE because not all of the
-   * instruction codes are used. */
+  /* There are many expected non-failures for ALT_CODE_TABLE because
+   * not all of the instruction codes are used. */
   IF_GENCODETBL (DO_TEST (decompress_single_bit_error, XD3_ALT_CODE_TABLE, 224));
 
 #ifndef WIN32
diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index 5a79bf4..0381206 100644
--- a/xdelta3/xdelta3.c
+++ b/xdelta3/xdelta3.c
@@ -4778,6 +4778,7 @@ static const xd3_smatcher XD3_TEMPLATE(__smatcher_) =
  *
  * TODO: really would like a good test for this logic. how?
  * TODO: optimize the inner loop
+ * TODO: do-templatize this
  */
 static int
 XD3_TEMPLATE(xd3_srcwin_move_point_) (xd3_stream *stream, usize_t *next_move_point)
@@ -4911,8 +4912,8 @@ XD3_TEMPLATE(xd3_srcwin_move_point_) (xd3_stream *stream, usize_t *next_move_poi
 static int
 XD3_TEMPLATE(xd3_string_match_) (xd3_stream *stream)
 {
-  /* TODO config: These next three variables should be statically compliled in various
-   * scan_cfg configurations? */
+  /* TODO config: These next three variables should be statically
+   * compliled in various scan_cfg configurations? */
   const int      DO_SMALL = ! (stream->flags & XD3_NOCOMPRESS);
   const int      DO_LARGE = (stream->src != NULL);
   const int      DO_RUN   = (1);