libmspack 0.10.1 → 0.11.0

data/ext/libmspack/mspack/lzx.h

@@ -67,7 +67,6 @@ struct lzxd_stream {
   unsigned int   block_remaining; /* uncompressed bytes still left to decode */
 
   signed int     intel_filesize;  /* magic header value used for transform   */
-  signed int     intel_curpos;    /* current offset in transform space       */
 
   unsigned char  intel_started;   /* has intel E8 decoding started?          */
   unsigned char  block_type;      /* type of the current block               */

data/ext/libmspack/mspack/lzxd.c

@@ -1,5 +1,5 @@
 /* This file is part of libmspack.
- * (C) 2003-2013 Stuart Caie.
+ * (C) 2003-2023 Stuart Caie.
  *
  * The LZX method was created by Jonathan Forbes and Tomi Poutanen, adapted
  * by Microsoft Corporation.
@@ -138,12 +138,7 @@
 static int lzxd_read_lens(struct lzxd_stream *lzx, unsigned char *lens,
                           unsigned int first, unsigned int last)
 {
-  /* bit buffer and huffman symbol decode variables */
-  register unsigned int bit_buffer;
-  register int bits_left, i;
-  register unsigned short sym;
-  unsigned char *i_ptr, *i_end;
-
+  DECLARE_HUFF_VARS;
   unsigned int x, y;
   int z;
 
@@ -315,8 +310,8 @@ struct lzxd_stream *lzxd_init(struct mspack_system *system,
   }
 
   /* allocate decompression window and input buffer */
-  lzx->window = (unsigned char *) system->alloc(system, (size_t) window_size);
-  lzx->inbuf  = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
+  lzx->window = (unsigned char *) system->alloc(system, window_size);
+  lzx->inbuf  = (unsigned char *) system->alloc(system, input_buffer_size);
   if (!lzx->window || !lzx->inbuf) {
     system->free(lzx->window);
     system->free(lzx->inbuf);
@@ -339,7 +334,6 @@ struct lzxd_stream *lzxd_init(struct mspack_system *system,
   lzx->frame           = 0;
   lzx->reset_interval  = reset_interval;
   lzx->intel_filesize  = 0;
-  lzx->intel_curpos    = 0;
   lzx->intel_started   = 0;
   lzx->error           = MSPACK_ERR_OK;
   lzx->num_offsets     = position_slots[window_bits - 15] << 3;
@@ -392,17 +386,10 @@ void lzxd_set_output_length(struct lzxd_stream *lzx, off_t out_bytes) {
 }
 
 int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
-  /* bitstream and huffman reading variables */
-  register unsigned int bit_buffer;
-  register int bits_left, i=0;
-  unsigned char *i_ptr, *i_end;
-  register unsigned short sym;
-
-  int match_length, length_footer, extra, verbatim_bits, bytes_todo;
-  int this_run, main_element, aligned_bits, j, warned = 0;
-  unsigned char *window, *runsrc, *rundest, buf[12];
-  unsigned int frame_size=0, end_frame, match_offset, window_posn;
-  unsigned int R0, R1, R2;
+  DECLARE_HUFF_VARS;
+  unsigned char *window, *runsrc, *rundest, buf[12], warned = 0;
+  unsigned int frame_size, end_frame, window_posn, R0, R1, R2;
+  int bytes_todo, this_run, i, j;
 
   /* easy answers */
   if (!lzx || (out_bytes < 0)) return MSPACK_ERR_ARGS;
@@ -524,9 +511,9 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
             READ_IF_NEEDED;
             *rundest++ = *i_ptr++;
           }
-          R0 = buf[0] | (buf[1] << 8) | (buf[2]  << 16) | (buf[3]  << 24);
-          R1 = buf[4] | (buf[5] << 8) | (buf[6]  << 16) | (buf[7]  << 24);
-          R2 = buf[8] | (buf[9] << 8) | (buf[10] << 16) | (buf[11] << 24);
+          R0 = EndGetI32(&buf[0]);
+          R1 = EndGetI32(&buf[4]);
+          R2 = EndGetI32(&buf[8]);
           break;
 
         default:
@@ -546,8 +533,12 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
 
       /* decode at least this_run bytes */
       switch (lzx->block_type) {
+      case LZX_BLOCKTYPE_ALIGNED:
       case LZX_BLOCKTYPE_VERBATIM:
         while (this_run > 0) {
+	  int main_element, length_footer, verbatim_bits, aligned_bits, extra;
+	  int match_length;
+	  unsigned int match_offset;
           READ_HUFFSYM(MAINTREE, main_element);
           if (main_element < LZX_NUM_CHARS) {
             /* literal: 0 to LZX_NUM_CHARS-1 */
@@ -572,137 +563,24 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
 
             /* get match offset */
             switch ((match_offset = (main_element >> 3))) {
-            case 0: match_offset = R0;                                  break;
-            case 1: match_offset = R1; R1=R0;        R0 = match_offset; break;
-            case 2: match_offset = R2; R2=R0;        R0 = match_offset; break;
-            case 3: match_offset = 1;  R2=R1; R1=R0; R0 = match_offset; break;
-            default:
-              extra = (match_offset >= 36) ? 17 : extra_bits[match_offset];
-              READ_BITS(verbatim_bits, extra);
-              match_offset = position_base[match_offset] - 2 + verbatim_bits;
-              R2 = R1; R1 = R0; R0 = match_offset;
-            }
-
-            /* LZX DELTA uses max match length to signal even longer match */
-            if (match_length == LZX_MAX_MATCH && lzx->is_delta) {
-                int extra_len = 0;
-                ENSURE_BITS(3); /* 4 entry huffman tree */
-                if (PEEK_BITS(1) == 0) {
-                    REMOVE_BITS(1); /* '0' -> 8 extra length bits */
-                    READ_BITS(extra_len, 8);
-                }
-                else if (PEEK_BITS(2) == 2) {
-                    REMOVE_BITS(2); /* '10' -> 10 extra length bits + 0x100 */
-                    READ_BITS(extra_len, 10);
-                    extra_len += 0x100;
-                }
-                else if (PEEK_BITS(3) == 6) {
-                    REMOVE_BITS(3); /* '110' -> 12 extra length bits + 0x500 */
-                    READ_BITS(extra_len, 12);
-                    extra_len += 0x500;
-                }
-                else {
-                    REMOVE_BITS(3); /* '111' -> 15 extra length bits */
-                    READ_BITS(extra_len, 15);
-                }
-                match_length += extra_len;
-            }
-
-            if ((window_posn + match_length) > lzx->window_size) {
-              D(("match ran over window wrap"))
-              return lzx->error = MSPACK_ERR_DECRUNCH;
-            }
-            
-            /* copy match */
-            rundest = &window[window_posn];
-            i = match_length;
-            /* does match offset wrap the window? */
-            if (match_offset > window_posn) {
-              if (match_offset > lzx->offset &&
-                  (match_offset - window_posn) > lzx->ref_data_size)
-              {
-                D(("match offset beyond LZX stream"))
-                return lzx->error = MSPACK_ERR_DECRUNCH;
-              }
-              /* j = length from match offset to end of window */
-              j = match_offset - window_posn;
-              if (j > (int) lzx->window_size) {
-                D(("match offset beyond window boundaries"))
-                return lzx->error = MSPACK_ERR_DECRUNCH;
-              }
-              runsrc = &window[lzx->window_size - j];
-              if (j < i) {
-                /* if match goes over the window edge, do two copy runs */
-                i -= j; while (j-- > 0) *rundest++ = *runsrc++;
-                runsrc = window;
-              }
-              while (i-- > 0) *rundest++ = *runsrc++;
-            }
-            else {
-              runsrc = rundest - match_offset;
-              while (i-- > 0) *rundest++ = *runsrc++;
-            }
-
-            this_run    -= match_length;
-            window_posn += match_length;
-          }
-        } /* while (this_run > 0) */
-        break;
-
-      case LZX_BLOCKTYPE_ALIGNED:
-        while (this_run > 0) {
-          READ_HUFFSYM(MAINTREE, main_element);
-          if (main_element < LZX_NUM_CHARS) {
-            /* literal: 0 to LZX_NUM_CHARS-1 */
-            window[window_posn++] = main_element;
-            this_run--;
-          }
-          else {
-            /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
-            main_element -= LZX_NUM_CHARS;
-
-            /* get match length */
-            match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
-            if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
-              if (lzx->LENGTH_empty) {
-                D(("LENGTH symbol needed but tree is empty"))
-                return lzx->error = MSPACK_ERR_DECRUNCH;
-              } 
-              READ_HUFFSYM(LENGTH, length_footer);
-              match_length += length_footer;
-            }
-            match_length += LZX_MIN_MATCH;
-
-            /* get match offset */
-            switch ((match_offset = (main_element >> 3))) {
-            case 0: match_offset = R0;                             break;
-            case 1: match_offset = R1; R1 = R0; R0 = match_offset; break;
-            case 2: match_offset = R2; R2 = R0; R0 = match_offset; break;
+            case 0: match_offset = R0; break;
+            case 1: match_offset = R1; R1=R0; R0 = match_offset; break;
+            case 2: match_offset = R2; R2=R0; R0 = match_offset; break;
             default:
               extra = (match_offset >= 36) ? 17 : extra_bits[match_offset];
               match_offset = position_base[match_offset] - 2;
-              if (extra > 3) {
-                /* verbatim and aligned bits */
-                extra -= 3;
-                READ_BITS(verbatim_bits, extra);
-                match_offset += (verbatim_bits << 3);
-                READ_HUFFSYM(ALIGNED, aligned_bits);
-                match_offset += aligned_bits;
-              }
-              else if (extra == 3) {
-                /* aligned bits only */
+              if (extra >= 3 && lzx->block_type == LZX_BLOCKTYPE_ALIGNED) {
+                if (extra > 3) {
+                  READ_BITS(verbatim_bits, extra - 3); /* 1-14 bits */
+                  match_offset += verbatim_bits << 3;
+                }
                 READ_HUFFSYM(ALIGNED, aligned_bits);
                 match_offset += aligned_bits;
               }
-              else if (extra > 0) { /* extra==1, extra==2 */
-                /* verbatim bits only */
-                READ_BITS(verbatim_bits, extra);
+              else if (extra) {
+                READ_BITS(verbatim_bits, extra); /* 1-17 bits */
                 match_offset += verbatim_bits;
               }
-              else /* extra == 0 */ {
-                /* ??? not defined in LZX specification! */
-                match_offset = 1;
-              }
               /* update repeated offset LRU queue */
               R2 = R1; R1 = R0; R0 = match_offset;
             }
@@ -742,7 +620,7 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
             i = match_length;
             /* does match offset wrap the window? */
             if (match_offset > window_posn) {
-              if (match_offset > lzx->offset &&
+	      if ((off_t)match_offset > lzx->offset &&
                   (match_offset - window_posn) > lzx->ref_data_size)
               {
                 D(("match offset beyond LZX stream"))
@@ -784,7 +662,7 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
           }
           else {
             if (i > this_run) i = this_run;
-            lzx->sys->copy(i_ptr, rundest, (size_t) i);
+            lzx->sys->copy(i_ptr, rundest, i);
             rundest  += i;
             i_ptr    += i;
             this_run -= i;
@@ -827,11 +705,11 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
 
     /* does this intel block _really_ need decoding? */
     if (lzx->intel_started && lzx->intel_filesize &&
-        (lzx->frame <= 32768) && (frame_size > 10))
+        (lzx->frame < 32768) && (frame_size > 10))
     {
       unsigned char *data    = &lzx->e8_buf[0];
       unsigned char *dataend = &lzx->e8_buf[frame_size - 10];
-      signed int curpos      = lzx->intel_curpos;
+      signed int curpos      = (int) lzx->offset;
       signed int filesize    = lzx->intel_filesize;
       signed int abs_off, rel_off;
 
@@ -841,7 +719,7 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
 
       while (data < dataend) {
         if (*data++ != 0xE8) { curpos++; continue; }
-        abs_off = data[0] | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);
+        abs_off = EndGetI32(data);
         if ((abs_off >= -curpos) && (abs_off < filesize)) {
           rel_off = (abs_off >= 0) ? abs_off - curpos : abs_off + filesize;
           data[0] = (unsigned char) rel_off;
@@ -852,11 +730,9 @@ int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
         data += 4;
         curpos += 5;
       }
-      lzx->intel_curpos += frame_size;
     }
     else {
       lzx->o_ptr = &lzx->window[lzx->frame_posn];
-      if (lzx->intel_filesize) lzx->intel_curpos += frame_size;
     }
     lzx->o_end = &lzx->o_ptr[frame_size];
 

data/ext/libmspack/mspack/macros.h

@@ -0,0 +1,64 @@
+/* This file is part of libmspack.
+ * (C) 2003-2020 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_MACROS_H
+#define MSPACK_MACROS_H 1
+
+/* define LD and LU as printf-format for signed and unsigned long offsets */
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# define PRId64 "lld"
+# define PRIu64 "llu"
+# define PRId32 "ld"
+# define PRIu32 "lu"
+#endif
+
+#if SIZEOF_OFF_T >= 8
+# define LD PRId64
+# define LU PRIu64
+#else
+# define LD PRId32
+# define LU PRIu32
+#endif
+
+/* endian-neutral reading of little-endian data */
+#define __egi32(a,n) (((unsigned int) ((unsigned char *)(a))[n+3] << 24) | \
+                      ((unsigned int) ((unsigned char *)(a))[n+2] << 16) | \
+                      ((unsigned int) ((unsigned char *)(a))[n+1] <<  8) | \
+                      ((unsigned int) ((unsigned char *)(a))[n]))
+#define EndGetI64(a) (((unsigned long long int) __egi32(a,4) << 32) | __egi32(a,0))
+#define EndGetI32(a) __egi32(a,0)
+#define EndGetI16(a) ((((a)[1])<<8)|((a)[0]))
+
+/* endian-neutral reading of big-endian data */
+#define EndGetM32(a) (((unsigned int) ((unsigned char *)(a))[0] << 24) | \
+                      ((unsigned int) ((unsigned char *)(a))[1] << 16) | \
+                      ((unsigned int) ((unsigned char *)(a))[2] <<  8) | \
+                      ((unsigned int) ((unsigned char *)(a))[3]))
+#define EndGetM16(a) ((((a)[0])<<8)|((a)[1]))
+
+/* D(("formatstring", args)) prints debug messages if DEBUG defined */
+#if DEBUG
+ /* http://gcc.gnu.org/onlinedocs/gcc/Function-Names.html */
+# if __STDC_VERSION__ < 199901L
+#  if __GNUC__ >= 2
+#   define __func__ __FUNCTION__
+#  else
+#   define __func__ "<unknown>"
+#  endif
+# endif
+# include <stdio.h>
+# define D(x) do { printf("%s:%d (%s) ",__FILE__, __LINE__, __func__); \
+                   printf x ; fputc('\n', stdout); fflush(stdout);} while (0);
+#else
+# define D(x)
+#endif
+
+#endif

data/ext/libmspack/mspack/mszipd.c

@@ -1,5 +1,5 @@
 /* This file is part of libmspack.
- * (C) 2003-2010 Stuart Caie.
+ * (C) 2003-2023 Stuart Caie.
  *
  * The deflate method was created by Phil Katz. MSZIP is equivalent to the
  * deflate method.
@@ -89,10 +89,7 @@ static const unsigned char bitlen_order[19] = {
 #define INF_ERR_HUFFSYM     (-14) /* out of bits decoding huffman symbol     */
 
 static int zip_read_lens(struct mszipd_stream *zip) {
-  /* for the bit buffer and huffman decoding */
-  register unsigned int bit_buffer;
-  register int bits_left;
-  unsigned char *i_ptr, *i_end;
+  DECLARE_BIT_VARS;
 
   /* bitlen Huffman codes -- immediate lookup, 7 bit max code length */
   unsigned short bl_table[(1 << 7)];
@@ -155,13 +152,9 @@ static int zip_read_lens(struct mszipd_stream *zip) {
 
 /* a clean implementation of RFC 1951 / inflate */
 static int inflate(struct mszipd_stream *zip) {
-  unsigned int last_block, block_type, distance, length, this_run, i;
-
-  /* for the bit buffer and huffman decoding */
-  register unsigned int bit_buffer;
-  register int bits_left;
-  register unsigned short sym;
-  unsigned char *i_ptr, *i_end;
+  DECLARE_HUFF_VARS;
+  unsigned int last_block, block_type, distance, length, this_run;
+  int i;
 
   RESTORE_BITS;
 
@@ -359,7 +352,7 @@ struct mszipd_stream *mszipd_init(struct mspack_system *system,
   }
 
   /* allocate input buffer */
-  zip->inbuf  = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
+  zip->inbuf  = (unsigned char *) system->alloc(system, input_buffer_size);
   if (!zip->inbuf) {
     system->free(zip);
     return NULL;
@@ -467,11 +460,7 @@ int mszipd_decompress(struct mszipd_stream *zip, off_t out_bytes) {
 }
 
 int mszipd_decompress_kwaj(struct mszipd_stream *zip) {
-    /* for the bit buffer */
-    register unsigned int bit_buffer;
-    register int bits_left;
-    unsigned char *i_ptr, *i_end;
-
+    DECLARE_BIT_VARS;
     int i, error, block_len;
 
     /* unpack blocks until block_len == 0 */

data/ext/libmspack/mspack/qtmd.c

@@ -1,5 +1,5 @@
 /* This file is part of libmspack.
- * (C) 2003-2004 Stuart Caie.
+ * (C) 2003-2023 Stuart Caie.
  *
  * The Quantum method was created by David Stafford, adapted by Microsoft
  * Corporation.
@@ -254,14 +254,12 @@ struct qtmd_stream *qtmd_init(struct mspack_system *system,
 }
 
 int qtmd_decompress(struct qtmd_stream *qtm, off_t out_bytes) {
+  DECLARE_BIT_VARS;
   unsigned int frame_todo, frame_end, window_posn, match_offset, range;
-  unsigned char *window, *i_ptr, *i_end, *runsrc, *rundest;
+  unsigned char *window, *runsrc, *rundest;
   int i, j, selector, extra, sym, match_length;
   unsigned short H, L, C, symf;
 
-  register unsigned int bit_buffer;
-  register unsigned char bits_left;
-
   /* easy answers */
   if (!qtm || (out_bytes < 0)) return MSPACK_ERR_ARGS;
   if (qtm->error) return qtm->error;

data/ext/libmspack/mspack/readbits.h

@@ -13,6 +13,7 @@
 /* this header defines macros that read data streams by
  * the individual bits
  *
+ * DECLARE_BIT_VARS  declares local variables
  * INIT_BITS         initialises bitstream state in state structure
  * STORE_BITS        stores bitstream state in state structure
  * RESTORE_BITS      restores bitstream state from state structure
@@ -92,13 +93,20 @@
 # endif
 #endif
 
+typedef unsigned int bitbuf_type;
+
 #if HAVE_LIMITS_H
 # include <limits.h>
 #endif
 #ifndef CHAR_BIT
 # define CHAR_BIT (8)
 #endif
-#define BITBUF_WIDTH (sizeof(bit_buffer) * CHAR_BIT)
+#define BITBUF_WIDTH (sizeof(bitbuf_type) * CHAR_BIT)
+
+#define DECLARE_BIT_VARS \
+   unsigned char *i_ptr, *i_end; \
+   register bitbuf_type bit_buffer; \
+   register int bits_left
 
 #define INIT_BITS do {                          \
     BITS_VAR->i_ptr      = &BITS_VAR->inbuf[0]; \
@@ -136,7 +144,7 @@
     unsigned char needed = (bits), bitrun;                      \
     (val) = 0;                                                  \
     while (needed > 0) {                                        \
-        if (bits_left <= (BITBUF_WIDTH - 16)) READ_BYTES;       \
+        if (bits_left <= (int)(BITBUF_WIDTH - 16)) READ_BYTES;	\
         bitrun = (bits_left < needed) ? bits_left : needed;     \
         (val) = ((val) << bitrun) | PEEK_BITS(bitrun);          \
         REMOVE_BITS(bitrun);                                    \
@@ -148,12 +156,13 @@
 # define PEEK_BITS(nbits)   (bit_buffer >> (BITBUF_WIDTH - (nbits)))
 # define REMOVE_BITS(nbits) ((bit_buffer <<= (nbits)), (bits_left -= (nbits)))
 # define INJECT_BITS(bitdata,nbits) ((bit_buffer |= \
-    (bitdata) << (BITBUF_WIDTH - (nbits) - bits_left)), (bits_left += (nbits)))
+    (bitbuf_type)(bitdata) << (BITBUF_WIDTH - (nbits) - bits_left)), \
+    (bits_left += (nbits)))
 #else /* BITS_ORDER_LSB */
-# define PEEK_BITS(nbits)   (bit_buffer & ((1 << (nbits))-1))
+# define PEEK_BITS(nbits)   (bit_buffer & ((bitbuf_type)(1 << (nbits))-1))
 # define REMOVE_BITS(nbits) ((bit_buffer >>= (nbits)), (bits_left -= (nbits)))
 # define INJECT_BITS(bitdata,nbits) ((bit_buffer |= \
-    (bitdata) << bits_left), (bits_left += (nbits)))
+    (bitbuf_type)(bitdata) << bits_left), (bits_left += (nbits)))
 #endif
 
 #ifdef BITS_LSB_TABLE

data/ext/libmspack/mspack/readhuff.h

@@ -28,35 +28,40 @@
 # define HUFF_MAXBITS 16
 #endif
 
+#define DECLARE_HUFF_VARS \
+   DECLARE_BIT_VARS; \
+   register int huff_idx; \
+   register unsigned short huff_sym
+
 /* Decodes the next huffman symbol from the input bitstream into var.
  * Do not use this macro on a table unless build_decode_table() succeeded.
  */
-#define READ_HUFFSYM(tbl, var) do {                     \
-    ENSURE_BITS(HUFF_MAXBITS);                          \
-    sym = HUFF_TABLE(tbl, PEEK_BITS(TABLEBITS(tbl)));   \
-    if (sym >= MAXSYMBOLS(tbl)) HUFF_TRAVERSE(tbl);     \
-    (var) = sym;                                        \
-    i = HUFF_LEN(tbl, sym);                             \
-    REMOVE_BITS(i);                                     \
+#define READ_HUFFSYM(tbl, var) do {                                 \
+    ENSURE_BITS(HUFF_MAXBITS);                                      \
+    huff_sym = HUFF_TABLE(tbl, PEEK_BITS(TABLEBITS(tbl)));          \
+    if (huff_sym >= MAXSYMBOLS(tbl)) HUFF_TRAVERSE(tbl);            \
+    (var) = huff_sym;                                               \
+    huff_idx = HUFF_LEN(tbl, huff_sym);                             \
+    REMOVE_BITS(huff_idx);                                          \
 } while (0)
 
 #ifdef BITS_ORDER_LSB
-# define HUFF_TRAVERSE(tbl) do {                        \
-    i = TABLEBITS(tbl) - 1;                             \
-    do {                                                \
-        if (i++ > HUFF_MAXBITS) HUFF_ERROR;             \
-        sym = HUFF_TABLE(tbl,                           \
-            (sym << 1) | ((bit_buffer >> i) & 1));      \
-    } while (sym >= MAXSYMBOLS(tbl));                   \
+# define HUFF_TRAVERSE(tbl) do {                                    \
+    huff_idx = TABLEBITS(tbl) - 1;                                  \
+    do {                                                            \
+        if (huff_idx++ > HUFF_MAXBITS) HUFF_ERROR;                  \
+        huff_sym = HUFF_TABLE(tbl,                                  \
+            (huff_sym << 1) | ((bit_buffer >> huff_idx) & 1));      \
+    } while (huff_sym >= MAXSYMBOLS(tbl));                          \
 } while (0)
 #else
-#define HUFF_TRAVERSE(tbl) do {                         \
-    i = 1 << (BITBUF_WIDTH - TABLEBITS(tbl));           \
-    do {                                                \
-        if ((i >>= 1) == 0) HUFF_ERROR;                 \
-        sym = HUFF_TABLE(tbl,                           \
-            (sym << 1) | ((bit_buffer & i) ? 1 : 0));   \
-    } while (sym >= MAXSYMBOLS(tbl));                   \
+#define HUFF_TRAVERSE(tbl) do {                                     \
+    huff_idx = 1 << (BITBUF_WIDTH - TABLEBITS(tbl));                \
+    do {                                                            \
+        if ((huff_idx >>= 1) == 0) HUFF_ERROR;                      \
+        huff_sym = HUFF_TABLE(tbl,                                  \
+            (huff_sym << 1) | ((bit_buffer & huff_idx) ? 1 : 0));   \
+    } while (huff_sym >= MAXSYMBOLS(tbl));                          \
 } while (0)
 #endif
 

data/ext/libmspack/mspack/system.c

@@ -13,11 +13,6 @@
 
 #include <system.h>
 
-#if !LARGEFILE_SUPPORT
-const char *largefile_msg = "library not compiled to support large files.";
-#endif
-
-
 int mspack_version(int entity) {
   switch (entity) {
    /* CHM decoder version 1 -> 2 changes:

data/ext/libmspack/mspack/system.h

@@ -18,11 +18,29 @@ extern "C" {
 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif
-
 #include <mspack.h>
+#include <macros.h>
 
 /* assume <string.h> exists */
-#include <string.h>
+#ifndef MSPACK_NO_DEFAULT_SYSTEM
+# include <string.h>
+#else
+ /* but if no default system wanted, avoid using <string.h> entirely,
+  * to avoid linking to even these standard C library functions */
+static inline int memcmp(const void *s1, const void *s2, size_t n) {
+    const unsigned char *a = s1, *b = s2;
+    while (n--) if (*a++ != *b++) return a[-1] - b[-1];
+    return 0;
+}
+static inline void *memset(void *s, int c, size_t n) {
+    unsigned char *s2 = s, c2 = (unsigned char) c;
+    while (n--) *s2++ = c2;
+    return s;
+}
+static inline size_t strlen(const char *s) {
+    size_t c = 0; while (*s++) c++; return c;
+}
+#endif
 
 /* fix for problem with GCC 4 and glibc (thanks to Ville Skytta)
  * http://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=150429
@@ -31,71 +49,6 @@ extern "C" {
 # undef read
 #endif
 
-/* Old GCCs don't have __func__, but __FUNCTION__:
- * http://gcc.gnu.org/onlinedocs/gcc/Function-Names.html
- */
-#if __STDC_VERSION__ < 199901L
-# if __GNUC__ >= 2
-#  define __func__ __FUNCTION__
-# else
-#  define __func__ "<unknown>"
-# endif
-#endif
-
-#if DEBUG
-# include <stdio.h>
-# define D(x) do { printf("%s:%d (%s) ",__FILE__, __LINE__, __func__); \
-                   printf x ; fputc('\n', stdout); fflush(stdout);} while (0);
-#else
-# define D(x)
-#endif
-
-/* CAB supports searching through files over 4GB in size, and the CHM file
- * format actively uses 64-bit offsets. These can only be fully supported
- * if the system the code runs on supports large files. If not, the library
- * will work as normal using only 32-bit arithmetic, but if an offset
- * greater than 2GB is detected, an error message indicating the library
- * can't support the file should be printed.
- */
-#if HAVE_INTTYPES_H
-# include <inttypes.h>
-#else
-# define PRId64 "lld"
-# define PRIu64 "llu"
-# define PRId32 "ld"
-# define PRIu32 "lu"
-#endif
-
-#include <limits.h>
-#if ((defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS >= 64) || \
-     (defined(FILESIZEBITS)      && FILESIZEBITS      >= 64) || \
-     defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE) || \
-     SIZEOF_OFF_T >= 8)
-# define LARGEFILE_SUPPORT 1
-# define LD PRId64
-# define LU PRIu64
-#else
-extern const char *largefile_msg;
-# define LD PRId32
-# define LU PRIu32
-#endif
-
-/* endian-neutral reading of little-endian data */
-#define __egi32(a,n) (((unsigned int) ((unsigned char *)(a))[n+3] << 24) | \
-                      ((unsigned int) ((unsigned char *)(a))[n+2] << 16) | \
-                      ((unsigned int) ((unsigned char *)(a))[n+1] <<  8) | \
-                      ((unsigned int) ((unsigned char *)(a))[n]))
-#define EndGetI64(a) (((unsigned long long int) __egi32(a,4) << 32) | __egi32(a,0))
-#define EndGetI32(a) __egi32(a,0)
-#define EndGetI16(a) ((((a)[1])<<8)|((a)[0]))
-
-/* endian-neutral reading of big-endian data */
-#define EndGetM32(a) (((unsigned int) ((unsigned char *)(a))[0] << 24) | \
-                      ((unsigned int) ((unsigned char *)(a))[1] << 16) | \
-                      ((unsigned int) ((unsigned char *)(a))[2] <<  8) | \
-                      ((unsigned int) ((unsigned char *)(a))[3]))
-#define EndGetM16(a) ((((a)[0])<<8)|((a)[1]))
-
 extern struct mspack_system *mspack_default_system;
 
 /* returns the length of a file opened for reading */