make_huffman_decode_table(): Fix comment

[wimlib] / src / decompress.c

diff --git a/src/decompress.c b/src/decompress.c
index 9a08621aea7e5b53aa93870537906c6109cf03b8..e97aab5c5c2f72cbf407ccacc65f8a750fb62f01 100644 (file)
--- a/src/decompress.c
+++ b/src/decompress.c
@@ -26,48 +26,6 @@
 #include "decompress.h"
 #include <string.h>
 
-/* Reads @n bytes from the bitstream @stream into the location pointed to by @dest.
- * The bitstream must be 16-bit aligned. */
-int bitstream_read_bytes(struct input_bitstream *stream, size_t n, void *dest)
-{
-       /* Precondition:  The bitstream is 16-byte aligned. */
-       wimlib_assert2(stream->bitsleft % 16 == 0);
-
-       u8 *p = dest;
-
-       /* Get the bytes currently in the buffer variable. */
-       while (stream->bitsleft != 0) {
-               if (n-- == 0)
-                       return 0;
-               *p++ = bitstream_peek_bits(stream, 8);
-               bitstream_remove_bits(stream, 8);
-       }
-
-       /* Get the rest directly from the pointer to the data.  Of course, it's
-        * necessary to check there are really n bytes available. */
-       if (n > stream->data_bytes_left) {
-               ERROR("Unexpected end of input when reading %zu bytes from "
-                     "bitstream (only have %u bytes left)",
-                     n, stream->data_bytes_left);
-               return 1;
-       }
-       memcpy(p, stream->data, n);
-       stream->data += n;
-       stream->data_bytes_left -= n;
-
-       /* It's possible to copy an odd number of bytes and leave the stream in
-        * an inconsistent state. Fix it by reading the next byte, if it is
-        * there. */
-       if ((n & 1) && stream->data_bytes_left != 0) {
-               stream->bitsleft = 8;
-               stream->data_bytes_left--;
-               stream->bitbuf |= (input_bitbuf_t)(*stream->data) <<
-                                       (sizeof(input_bitbuf_t) * 8 - 8);
-               stream->data++;
-       }
-       return 0;
-}
-
 /*
  * Builds a fast huffman decoding table from an array that gives the length of
  * the codeword for each symbol in the alphabet.  Originally based on code
@@ -80,7 +38,8 @@ int bitstream_read_bytes(struct input_bitstream *stream, size_t n, void *dest)
  *                     (2**table_bits) + 2 * num_syms to guarantee
  *                     that there is enough space.
  *
- * @num_syms:          Total number of symbols in the Huffman tree.
+ * @num_syms:          Number of symbols in the alphabet, including symbols
+ *                     that do not appear in this particular input chunk.
  *
  * @table_bits:                Any symbols with a code length of table_bits or less can
  *                     be decoded in one lookup of the table.  2**table_bits
@@ -88,7 +47,7 @@ int bitstream_read_bytes(struct input_bitstream *stream, size_t n, void *dest)
  *                     any Huffman codes longer than @table_bits.
  *
  * @lens:              An array of length @num_syms, indexable by symbol, that
- *                     gives the length of the Huffman codeward for that
+ *                     gives the length of the Huffman codeword for that
  *                     symbol.  Because the Huffman tree is in canonical form,
  *                     it can be reconstructed by only knowing the length of
  *                     the codeword for each symbol.  It is assumed, but not
@@ -205,17 +164,15 @@ int make_huffman_decode_table(u16 decode_table[],  unsigned num_syms,
                        break;
 
                unsigned num_entries = 1 << (table_bits - codeword_len);
-               if (num_entries >=
-                       (sizeof(unsigned long) / sizeof(decode_table[0])))
-               {
-                       wimlib_assert2(decode_table_pos % 4 == 0);
+               const unsigned entries_per_long = sizeof(unsigned long) /
+                                                 sizeof(decode_table[0]);
+               if (num_entries >= entries_per_long) {
+                       wimlib_assert2(decode_table_pos % entries_per_long == 0);
                        BUILD_BUG_ON(sizeof(unsigned long) != 4 &&
                                     sizeof(unsigned long) != 8);
 
                        unsigned long *p = (unsigned long *)&decode_table[decode_table_pos];
-                       unsigned long n = num_entries /
-                                               (sizeof(unsigned long) /
-                                                       sizeof(decode_table[0]));
+                       unsigned n = num_entries / entries_per_long;
                        unsigned long v = sym;
                        if (sizeof(unsigned long) >= 4)
                                v |= v << 16;
@@ -356,7 +313,7 @@ int read_huffsym_near_end_of_input(struct input_bitstream *istream,
                do {
                        if (bitsleft == 0) {
                                ERROR("Input stream exhausted");
-                               return 1;
+                               return -1;
                        }
                        key_bits = sym + bitstream_peek_bits(istream, 1);
                        bitstream_remove_bits(istream, 1);