Changed issues from PR comments.

Author: mkrueger

src/legacy/huffman.rs

@@ -19,25 +19,23 @@ const HUFFMAN_LOOKUP_TABLE_BITS: u8 = 8;
 
 pub struct HuffmanDecoder {
     /// Lookup table for fast decoding of short codewords.
-    pub table: Vec<TableEntry>,
+    pub table: [TableEntry; 1 << HUFFMAN_LOOKUP_TABLE_BITS],
     /// "Sentinel bits" value for each codeword length.
-    pub sentinel_bits: Vec<u32>,
+    pub sentinel_bits: [u32; MAX_HUFFMAN_BITS + 1],
     /// First symbol index minus first codeword mod 2**16 for each length.
-    pub offset_first_sym_idx: Vec<u16>,
+    pub offset_first_sym_idx: [u16; MAX_HUFFMAN_BITS + 1],
     /// Map from symbol index to symbol.
-    pub syms: Vec<u16>,
+    pub syms: [u16; MAX_HUFFMAN_SYMBOLS],
     // num_syms:usize
 }
 
 impl Default for HuffmanDecoder {
     fn default() -> Self {
-        let syms = vec![0; MAX_HUFFMAN_SYMBOLS];
-        let table = vec![TableEntry::default(); 1 << HUFFMAN_LOOKUP_TABLE_BITS];
         Self {
-            table,
-            sentinel_bits: vec![0; MAX_HUFFMAN_BITS + 1],
-            offset_first_sym_idx: vec![0; MAX_HUFFMAN_BITS + 1],
-            syms,
+            table: [TableEntry::default(); 1 << HUFFMAN_LOOKUP_TABLE_BITS],
+            sentinel_bits: [0; MAX_HUFFMAN_BITS + 1],
+            offset_first_sym_idx: [0; MAX_HUFFMAN_BITS + 1],
+            syms: [0; MAX_HUFFMAN_SYMBOLS],
         }
     }
 }
@@ -157,7 +155,7 @@ impl HuffmanDecoder {
             MAX_HUFFMAN_BITS,
         );
 
-        for l in HUFFMAN_LOOKUP_TABLE_BITS as usize + 1..=MAX_HUFFMAN_BITS {
+        for l in (HUFFMAN_LOOKUP_TABLE_BITS as usize + 1)..=MAX_HUFFMAN_BITS {
             if (bits as u32) < self.sentinel_bits[l] {
                 bits >>= MAX_HUFFMAN_BITS - l;
                 let sym_idx = (self.offset_first_sym_idx[l] as usize + bits as usize) & 0xFFFF;

src/legacy/implode.rs

@@ -9,7 +9,7 @@ use std::io::{self, Cursor, Error, Read, Result};
 fn read_huffman_code<T: std::io::Read, E: Endianness>(
     is: &mut BitReader<T, E>,
     num_lens: usize,
-) -> std::io::Result<HuffmanDecoder> {
+) -> std::io::Result<Box<HuffmanDecoder>> {
     let mut lens = [0; 1 << 8];
     let mut len_count = [0; 17];
     // debug_assert!(num_lens <= sizeof(lens) / sizeof(lens[0]));
@@ -71,7 +71,7 @@ fn read_huffman_code<T: std::io::Read, E: Endianness>(
         ));
     }
 
-    let mut d = HuffmanDecoder::default();
+    let mut d = Box::new(HuffmanDecoder::default());
     d.init(&lens, num_lens)?;
     Ok(d)
 }
@@ -205,7 +205,7 @@ impl<R: Read> Read for ImplodeDecoder<R> {
 mod tests {
     use super::hwexplode;
     use std::collections::VecDeque;
-    const HAMLET_256: &[u8; 249] = include_bytes!("../../tests/implode_hamlet_256.bin");
+    const HAMLET_256: &[u8; 249] = include_bytes!("../../tests/data/legacy/implode_hamlet_256.bin");
 
     #[test]
     fn test_explode_hamlet_256() {

src/legacy/reduce.rs

@@ -47,9 +47,14 @@ fn read_follower_sets<T: std::io::Read, E: Endianness>(
     Ok(fsets)
 }
 
+
 /// Read the next byte from is, decoded based on prev_byte and the follower sets.
-/// The byte is returned in *out_byte. The function returns true on success,
-/// and false on bad data or end of input.
+/// The byte is returned in *out_byte. 
+/// 
+/// # Returns
+/// 
+/// * `Ok(())` if the byte was successfully read.
+/// * `Err(io::Error)` on bad data or end of input.
 fn read_next_byte<T: std::io::Read, E: Endianness>(
     is: &mut BitReader<T, E>,
     prev_byte: u8,
@@ -215,7 +220,7 @@ mod tests {
     use super::hwexpand;
     use crate::legacy::reduce::{follower_idx_bw, lsb, max_dist};
     use std::collections::VecDeque;
-    const HAMLET_2048: &[u8; 1285] = include_bytes!("../../tests/reduce_hamlet_2048.bin");
+    const HAMLET_2048: &[u8; 1285] = include_bytes!("../../tests/data/legacy/reduce_hamlet_2048.bin");
 
     #[test]
     fn test_lsb() {
@@ -243,7 +248,7 @@ mod tests {
       $ dosbox -c "mount c ." -c "c:" -c "pkzip -ea4 a.zip a" -c "exit"
       $ xxd -i -s 31 -l $(expr $(find A.ZIP -printf %s) - 100) A.ZIP
     */
-    const ZEROS_REDUCED: &[u8; 1297] = include_bytes!("../../tests/reduce_zero_reduced.bin");
+    const ZEROS_REDUCED: &[u8; 1297] = include_bytes!("../../tests/data/legacy/reduce_zero_reduced.bin");
 
     #[test]
     fn test_expand_zeros() {

src/legacy/shrink.rs

@@ -17,12 +17,12 @@ const UNKNOWN_LEN: u16 = u16::MAX;
 
 struct CodeQueue {
     next_idx: usize,
-    codes: Vec<Option<u16>>,
+    codes: [Option<u16>; MAX_CODE - CONTROL_CODE + 1]
 }
 
 impl CodeQueue {
     fn new() -> Self {
-        let mut codes = vec![None; MAX_CODE as usize - CONTROL_CODE + 1];
+        let mut codes = [None; MAX_CODE as usize - CONTROL_CODE + 1];
         for (i, code) in (CONTROL_CODE as u16 + 1..=MAX_CODE as u16).enumerate() {
             codes[i] = Some(code);
         }
@@ -151,25 +151,23 @@ fn read_code<T: std::io::Read, E: Endianness>(
     Ok(None)
 }
 
-/// Output the string represented by a code into dst at dst_pos. Returns
-/// HWUNSHRINK_OK on success, and also updates *first_byte and *len with the
-/// first byte and length of the output string, respectively.
+/// Output the string represented by a code into dst at dst_pos. 
+/// 
+/// # Returns
+/// new first byte of the string, or io::Error InvalidData on invalid prefix code.
 fn output_code(
-    code: u16,
     dst: &mut VecDeque<u8>,
+    code: u16,
     prev_code: u16,
     codetab: &mut [Codetab],
-    queue: &mut CodeQueue,
-    first_byte: &mut u8,
-    len: &mut usize,
-) -> io::Result<()> {
+    queue: &CodeQueue,
+    first_byte: u8,
+) -> io::Result<u8> {
     debug_assert!(code <= MAX_CODE as u16 && code != CONTROL_CODE as u16);
     if code <= u8::MAX as u16 {
         // Output literal byte.
-        *first_byte = code as u8;
-        *len = 1;
         dst.push_back(code as u8);
-        return Ok(());
+        return Ok(code as u8);
     }
 
     if codetab[code as usize].prefix_code.is_none()
@@ -186,9 +184,7 @@ fn output_code(
         for i in ct.last_dst_pos..ct.last_dst_pos + ct.len as usize {
             dst.push_back(dst[i]);
         }
-        *first_byte = dst[ct.last_dst_pos];
-        *len = ct.len as usize;
-        return Ok(());
+        return Ok(dst[ct.last_dst_pos]);
     }
 
     // Output a string of unknown length. This happens when the prefix
@@ -208,11 +204,11 @@ fn output_code(
         with its first byte. */
         codetab[prefix_code as usize] = Codetab {
             prefix_code: Some(prev_code),
-            ext_byte: *first_byte,
+            ext_byte: first_byte,
             len: codetab[prev_code as usize].len + 1,
             last_dst_pos: codetab[prev_code as usize].last_dst_pos,
         };
-        dst.push_back(*first_byte);
+        dst.push_back(first_byte);
     } else if codetab[prefix_code as usize].prefix_code.is_none() {
         // The prefix code is still invalid.
         return Err(io::Error::new(
@@ -222,26 +218,26 @@ fn output_code(
     }
 
     // Output the prefix string, then the extension byte.
-    *len = codetab[prefix_code as usize].len as usize + 1;
+    let len = codetab[prefix_code as usize].len as usize + 1;
     let last_dst_pos = dst.len();
     let ct = &codetab[prefix_code as usize];
     for i in ct.last_dst_pos..ct.last_dst_pos + ct.len as usize {
         dst.push_back(dst[i]);
     }
     dst.push_back(codetab[code as usize].ext_byte);
-    *first_byte = dst[ct.last_dst_pos];
+    let res = dst[ct.last_dst_pos];
 
     // Update the code table now that the string has a length and pos.
     debug_assert!(prev_code != code);
-    codetab[code as usize].len = *len as u16;
+    codetab[code as usize].len = len as u16;
     codetab[code as usize].last_dst_pos = last_dst_pos;
 
-    Ok(())
+    Ok(res)
 }
 
 fn hwunshrink(src: &[u8], uncompressed_size: usize, dst: &mut VecDeque<u8>) -> io::Result<()> {
     let mut codetab = Codetab::create_new();
-    let mut queue = CodeQueue::new();
+    let mut queue = Box::new(CodeQueue::new());
     let mut is = BitReader::endian(src, LittleEndian);
 
     let mut code_size = MIN_CODE_SIZE;
@@ -258,7 +254,7 @@ fn hwunshrink(src: &[u8], uncompressed_size: usize, dst: &mut VecDeque<u8>) -> i
             "the first code must be a literal",
         ));
     }
-    let mut first_byte = curr_code as u8;
+    let first_byte = curr_code as u8;
     codetab[curr_code as usize].last_dst_pos = dst.len();
     dst.push_back(curr_code as u8);
 
@@ -293,15 +289,13 @@ fn hwunshrink(src: &[u8], uncompressed_size: usize, dst: &mut VecDeque<u8>) -> i
         }
 
         // Output the string represented by the current code.
-        let mut len = 0;
-        output_code(
-            curr_code,
+        let first_byte = output_code(
             dst,
+            curr_code,
             prev_code,
             &mut codetab,
             &mut queue,
-            &mut first_byte,
-            &mut len,
+            first_byte,
         )?;
 
         // Add a new code to the string table if there's room.

tests/data/implode.zip renamed to tests/data/legacy/implode.zip

@@ -6,7 +6,7 @@ use zip::ZipArchive;
 #[test]
 fn decompress_shrink() {
     let mut v = Vec::new();
-    v.extend_from_slice(include_bytes!("data/shrink.zip"));
+    v.extend_from_slice(include_bytes!("data/legacy/shrink.zip"));
     let mut archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file");
 
     let mut file = archive
@@ -23,7 +23,7 @@ fn decompress_shrink() {
 #[test]
 fn decompress_reduce() {
     let mut v = Vec::new();
-    v.extend_from_slice(include_bytes!("data/reduce.zip"));
+    v.extend_from_slice(include_bytes!("data/legacy/reduce.zip"));
     let mut archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file");
 
     let mut file = archive
@@ -40,7 +40,7 @@ fn decompress_reduce() {
 #[test]
 fn decompress_implode() {
     let mut v = Vec::new();
-    v.extend_from_slice(include_bytes!("data/implode.zip"));
+    v.extend_from_slice(include_bytes!("data/legacy/implode.zip"));
     let mut archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file");
 
     let mut file = archive