libmspack 0.0.5 → 0.10.1.2

data/ext/libmspack/mspack/qtmd.c

@@ -27,11 +27,11 @@
 #define BITS_TYPE struct qtmd_stream
 #define BITS_VAR qtm
 #define BITS_ORDER_MSB
-#define READ_BYTES do {			\
-    unsigned char b0, b1;		\
-    READ_IF_NEEDED; b0 = *i_ptr++;	\
-    READ_IF_NEEDED; b1 = *i_ptr++;	\
-    INJECT_BITS((b0 << 8) | b1, 16);	\
+#define READ_BYTES do {                 \
+    unsigned char b0, b1;               \
+    READ_IF_NEEDED; b0 = *i_ptr++;      \
+    READ_IF_NEEDED; b1 = *i_ptr++;      \
+    INJECT_BITS((b0 << 8) | b1, 16);    \
 } while (0)
 #include <readbits.h>
 
@@ -115,7 +115,7 @@ static const unsigned char length_extra[27] = {
       else break;                                                       \
     }                                                                   \
     L <<= 1; H = (H << 1) | 1;                                          \
-    ENSURE_BITS(1);							\
+    ENSURE_BITS(1);                                                     \
     C  = (C << 1) | PEEK_BITS(1);                                       \
     REMOVE_BITS(1);                                                     \
   }                                                                     \
@@ -130,7 +130,7 @@ static void qtmd_update_model(struct qtmd_model *model) {
       /* -1, not -2; the 0 entry saves this */
       model->syms[i].cumfreq >>= 1;
       if (model->syms[i].cumfreq <= model->syms[i+1].cumfreq) {
-	model->syms[i].cumfreq = model->syms[i+1].cumfreq + 1;
+        model->syms[i].cumfreq = model->syms[i+1].cumfreq + 1;
       }
     }
   }
@@ -149,11 +149,11 @@ static void qtmd_update_model(struct qtmd_model *model) {
      * characteristics */
     for (i = 0; i < model->entries - 1; i++) {
       for (j = i + 1; j < model->entries; j++) {
-	if (model->syms[i].cumfreq < model->syms[j].cumfreq) {
-	  tmp = model->syms[i];
-	  model->syms[i] = model->syms[j];
-	  model->syms[j] = tmp;
-	}
+        if (model->syms[i].cumfreq < model->syms[j].cumfreq) {
+          tmp = model->syms[i];
+          model->syms[i] = model->syms[j];
+          model->syms[j] = tmp;
+        }
       }
     }
 
@@ -166,7 +166,7 @@ static void qtmd_update_model(struct qtmd_model *model) {
 
 /* Initialises a model to decode symbols from [start] to [start]+[len]-1 */
 static void qtmd_init_model(struct qtmd_model *model,
-			    struct qtmd_modelsym *syms, int start, int len)
+                            struct qtmd_modelsym *syms, int start, int len)
 {
   int i;
 
@@ -184,9 +184,9 @@ static void qtmd_init_model(struct qtmd_model *model,
 /*-------- main Quantum code --------*/
 
 struct qtmd_stream *qtmd_init(struct mspack_system *system,
-			      struct mspack_file *input,
-			      struct mspack_file *output,
-			      int window_bits, int input_buffer_size)
+                              struct mspack_file *input,
+                              struct mspack_file *output,
+                              int window_bits, int input_buffer_size)
 {
   unsigned int window_size = 1 << window_bits;
   struct qtmd_stream *qtm;
@@ -197,6 +197,7 @@ struct qtmd_stream *qtmd_init(struct mspack_system *system,
   /* Quantum supports window sizes of 2^10 (1Kb) through 2^21 (2Mb) */
   if (window_bits < 10 || window_bits > 21) return NULL;
 
+  /* round up input buffer size to multiple of two */
   input_buffer_size = (input_buffer_size + 1) & -2;
   if (input_buffer_size < 2) return NULL;
 
@@ -307,113 +308,113 @@ int qtmd_decompress(struct qtmd_stream *qtm, off_t out_bytes) {
     while (window_posn < frame_end) {
       GET_SYMBOL(qtm->model7, selector);
       if (selector < 4) {
-	/* literal byte */
-	struct qtmd_model *mdl = (selector == 0) ? &qtm->model0 :
-	                        ((selector == 1) ? &qtm->model1 :
-				((selector == 2) ? &qtm->model2 :
+        /* literal byte */
+        struct qtmd_model *mdl = (selector == 0) ? &qtm->model0 :
+                                ((selector == 1) ? &qtm->model1 :
+                                ((selector == 2) ? &qtm->model2 :
                                                    &qtm->model3));
-	GET_SYMBOL((*mdl), sym);
-	window[window_posn++] = sym;
-	frame_todo--;
+        GET_SYMBOL((*mdl), sym);
+        window[window_posn++] = sym;
+        frame_todo--;
       }
       else {
-	/* match repeated string */
-	switch (selector) {
-	case 4: /* selector 4 = fixed length match (3 bytes) */
-	  GET_SYMBOL(qtm->model4, sym);
-	  READ_MANY_BITS(extra, extra_bits[sym]);
-	  match_offset = position_base[sym] + extra + 1;
-	  match_length = 3;
-	  break;
-
-	case 5: /* selector 5 = fixed length match (4 bytes) */
-	  GET_SYMBOL(qtm->model5, sym);
-	  READ_MANY_BITS(extra, extra_bits[sym]);
-	  match_offset = position_base[sym] + extra + 1;
-	  match_length = 4;
-	  break;
-
-	case 6: /* selector 6 = variable length match */
-	  GET_SYMBOL(qtm->model6len, sym);
-	  READ_MANY_BITS(extra, length_extra[sym]);
-	  match_length = length_base[sym] + extra + 5;
-
-	  GET_SYMBOL(qtm->model6, sym);
-	  READ_MANY_BITS(extra, extra_bits[sym]);
-	  match_offset = position_base[sym] + extra + 1;
-	  break;
-
-	default:
-	  /* should be impossible, model7 can only return 0-6 */
-	  D(("got %d from selector", selector))
-	  return qtm->error = MSPACK_ERR_DECRUNCH;
-	}
-
-	rundest = &window[window_posn];
-	frame_todo -= match_length;
-
-	/* does match destination wrap the window? This situation is possible
-	 * where the window size is less than the 32k frame size, but matches
-	 * must not go beyond a frame boundary */
-	if ((window_posn + match_length) > qtm->window_size) {
+        /* match repeated string */
+        switch (selector) {
+        case 4: /* selector 4 = fixed length match (3 bytes) */
+          GET_SYMBOL(qtm->model4, sym);
+          READ_MANY_BITS(extra, extra_bits[sym]);
+          match_offset = position_base[sym] + extra + 1;
+          match_length = 3;
+          break;
+
+        case 5: /* selector 5 = fixed length match (4 bytes) */
+          GET_SYMBOL(qtm->model5, sym);
+          READ_MANY_BITS(extra, extra_bits[sym]);
+          match_offset = position_base[sym] + extra + 1;
+          match_length = 4;
+          break;
+
+        case 6: /* selector 6 = variable length match */
+          GET_SYMBOL(qtm->model6len, sym);
+          READ_MANY_BITS(extra, length_extra[sym]);
+          match_length = length_base[sym] + extra + 5;
+
+          GET_SYMBOL(qtm->model6, sym);
+          READ_MANY_BITS(extra, extra_bits[sym]);
+          match_offset = position_base[sym] + extra + 1;
+          break;
+
+        default:
+          /* should be impossible, model7 can only return 0-6 */
+          D(("got %d from selector", selector))
+          return qtm->error = MSPACK_ERR_DECRUNCH;
+        }
+
+        rundest = &window[window_posn];
+        frame_todo -= match_length;
+
+        /* does match destination wrap the window? This situation is possible
+         * where the window size is less than the 32k frame size, but matches
+         * must not go beyond a frame boundary */
+        if ((window_posn + match_length) > qtm->window_size) {
           /* copy first part of match, before window end */
-	  i = qtm->window_size - window_posn;
-	  j = window_posn - match_offset;
-	  while (i--) *rundest++ = window[j++ & (qtm->window_size - 1)];
-
-	  /* flush currently stored data */
-	  i = (&window[qtm->window_size] - qtm->o_ptr);
-
-	  /* this should not happen, but if it does then this code
-	   * can't handle the situation (can't flush up to the end of
-	   * the window, but can't break out either because we haven't
-	   * finished writing the match). bail out in this case */
-	  if (i > out_bytes) {
-	    D(("during window-wrap match; %d bytes to flush but only need %d",
-	       i, (int) out_bytes))
-	    return qtm->error = MSPACK_ERR_DECRUNCH;
-	  }
-	  if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
-	    return qtm->error = MSPACK_ERR_WRITE;
-	  }
-	  out_bytes -= i;
-	  qtm->o_ptr = &window[0];
-	  qtm->o_end = &window[0]; 
-
-	  /* copy second part of match, after window wrap */
-	  rundest = &window[0];
-	  i = match_length - (qtm->window_size - window_posn);
-	  while (i--) *rundest++ = window[j++ & (qtm->window_size - 1)];
-	  window_posn = window_posn + match_length - qtm->window_size;
+          i = qtm->window_size - window_posn;
+          j = window_posn - match_offset;
+          while (i--) *rundest++ = window[j++ & (qtm->window_size - 1)];
+
+          /* flush currently stored data */
+          i = (&window[qtm->window_size] - qtm->o_ptr);
+
+          /* this should not happen, but if it does then this code
+           * can't handle the situation (can't flush up to the end of
+           * the window, but can't break out either because we haven't
+           * finished writing the match). bail out in this case */
+          if (i > out_bytes) {
+            D(("during window-wrap match; %d bytes to flush but only need %d",
+               i, (int) out_bytes))
+            return qtm->error = MSPACK_ERR_DECRUNCH;
+          }
+          if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
+            return qtm->error = MSPACK_ERR_WRITE;
+          }
+          out_bytes -= i;
+          qtm->o_ptr = &window[0];
+          qtm->o_end = &window[0]; 
+
+          /* copy second part of match, after window wrap */
+          rundest = &window[0];
+          i = match_length - (qtm->window_size - window_posn);
+          while (i--) *rundest++ = window[j++ & (qtm->window_size - 1)];
+          window_posn = window_posn + match_length - qtm->window_size;
 
           break; /* because "window_posn < frame_end" has now failed */
-	}
-	else {
+        }
+        else {
           /* normal match - output won't wrap window or frame end */
-	  i = match_length;
-
-	  /* does match _offset_ wrap the window? */
-	  if (match_offset > window_posn) {
-	    /* j = length from match offset to end of window */
-	    j = match_offset - window_posn;
-	    if (j > (int) qtm->window_size) {
-	      D(("match offset beyond window boundaries"))
-	      return qtm->error = MSPACK_ERR_DECRUNCH;
-	    }
-	    runsrc = &window[qtm->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++;
-	  }
-	  window_posn += match_length;
-	}
+          i = match_length;
+
+          /* does match _offset_ wrap the window? */
+          if (match_offset > window_posn) {
+            /* j = length from match offset to end of window */
+            j = match_offset - window_posn;
+            if (j > (int) qtm->window_size) {
+              D(("match offset beyond window boundaries"))
+              return qtm->error = MSPACK_ERR_DECRUNCH;
+            }
+            runsrc = &window[qtm->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++;
+          }
+          window_posn += match_length;
+        }
       } /* if (window_posn+match_length > frame_end) */
     } /* while (window_posn < frame_end) */
 
@@ -448,7 +449,7 @@ int qtmd_decompress(struct qtmd_stream *qtm, off_t out_bytes) {
       /* break out if we have more than enough to finish this request */
       if (i >= out_bytes) break;
       if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
-	return qtm->error = MSPACK_ERR_WRITE;
+        return qtm->error = MSPACK_ERR_WRITE;
       }
       out_bytes -= i;
       qtm->o_ptr = &window[0];

data/ext/libmspack/mspack/readbits.h

@@ -100,48 +100,48 @@
 #endif
 #define BITBUF_WIDTH (sizeof(bit_buffer) * CHAR_BIT)
 
-#define INIT_BITS do {				\
-    BITS_VAR->i_ptr      = &BITS_VAR->inbuf[0];	\
-    BITS_VAR->i_end      = &BITS_VAR->inbuf[0];	\
-    BITS_VAR->bit_buffer = 0;			\
-    BITS_VAR->bits_left  = 0;			\
-    BITS_VAR->input_end  = 0;			\
+#define INIT_BITS do {                          \
+    BITS_VAR->i_ptr      = &BITS_VAR->inbuf[0]; \
+    BITS_VAR->i_end      = &BITS_VAR->inbuf[0]; \
+    BITS_VAR->bit_buffer = 0;                   \
+    BITS_VAR->bits_left  = 0;                   \
+    BITS_VAR->input_end  = 0;                   \
 } while (0)
 
-#define STORE_BITS do {			\
-    BITS_VAR->i_ptr      = i_ptr;	\
-    BITS_VAR->i_end      = i_end;	\
-    BITS_VAR->bit_buffer = bit_buffer;	\
-    BITS_VAR->bits_left  = bits_left;	\
+#define STORE_BITS do {                 \
+    BITS_VAR->i_ptr      = i_ptr;       \
+    BITS_VAR->i_end      = i_end;       \
+    BITS_VAR->bit_buffer = bit_buffer;  \
+    BITS_VAR->bits_left  = bits_left;   \
 } while (0)
 
-#define RESTORE_BITS do {		\
-    i_ptr      = BITS_VAR->i_ptr;	\
-    i_end      = BITS_VAR->i_end;	\
-    bit_buffer = BITS_VAR->bit_buffer;	\
-    bits_left  = BITS_VAR->bits_left;	\
+#define RESTORE_BITS do {               \
+    i_ptr      = BITS_VAR->i_ptr;       \
+    i_end      = BITS_VAR->i_end;       \
+    bit_buffer = BITS_VAR->bit_buffer;  \
+    bits_left  = BITS_VAR->bits_left;   \
 } while (0)
 
-#define ENSURE_BITS(nbits) do {			\
-    while (bits_left < (nbits)) READ_BYTES;	\
+#define ENSURE_BITS(nbits) do {                 \
+    while (bits_left < (nbits)) READ_BYTES;     \
 } while (0)
 
-#define READ_BITS(val, nbits) do {		\
-    ENSURE_BITS(nbits);				\
-    (val) = PEEK_BITS(nbits);			\
-    REMOVE_BITS(nbits);				\
+#define READ_BITS(val, nbits) do {              \
+    ENSURE_BITS(nbits);                         \
+    (val) = PEEK_BITS(nbits);                   \
+    REMOVE_BITS(nbits);                         \
 } while (0)
 
-#define READ_MANY_BITS(val, bits) do {				\
-    unsigned char needed = (bits), bitrun;			\
-    (val) = 0;							\
-    while (needed > 0) {					\
-	if (bits_left <= (BITBUF_WIDTH - 16)) READ_BYTES;	\
-	bitrun = (bits_left < needed) ? bits_left : needed;	\
-	(val) = ((val) << bitrun) | PEEK_BITS(bitrun);		\
-	REMOVE_BITS(bitrun);					\
-	needed -= bitrun;					\
-    }								\
+#define READ_MANY_BITS(val, bits) do {                          \
+    unsigned char needed = (bits), bitrun;                      \
+    (val) = 0;                                                  \
+    while (needed > 0) {                                        \
+        if (bits_left <= (BITBUF_WIDTH - 16)) READ_BYTES;       \
+        bitrun = (bits_left < needed) ? bits_left : needed;     \
+        (val) = ((val) << bitrun) | PEEK_BITS(bitrun);          \
+        REMOVE_BITS(bitrun);                                    \
+        needed -= bitrun;                                       \
+    }                                                           \
 } while (0)
 
 #ifdef BITS_ORDER_MSB
@@ -163,21 +163,21 @@ static const unsigned short lsb_bit_mask[17] = {
     0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
 };
 # define PEEK_BITS_T(nbits) (bit_buffer & lsb_bit_mask[(nbits)])
-# define READ_BITS_T(val, nbits) do {	\
-    ENSURE_BITS(nbits);			\
-    (val) = PEEK_BITS_T(nbits);		\
-    REMOVE_BITS(nbits);			\
+# define READ_BITS_T(val, nbits) do {   \
+    ENSURE_BITS(nbits);                 \
+    (val) = PEEK_BITS_T(nbits);         \
+    REMOVE_BITS(nbits);                 \
 } while (0)
 #endif
 
 #ifndef BITS_NO_READ_INPUT
-# define READ_IF_NEEDED do {		\
-    if (i_ptr >= i_end) {		\
-	if (read_input(BITS_VAR))	\
-	    return BITS_VAR->error;	\
-	i_ptr = BITS_VAR->i_ptr;	\
-	i_end = BITS_VAR->i_end;	\
-    }					\
+# define READ_IF_NEEDED do {            \
+    if (i_ptr >= i_end) {               \
+        if (read_input(BITS_VAR))       \
+            return BITS_VAR->error;     \
+        i_ptr = BITS_VAR->i_ptr;        \
+        i_end = BITS_VAR->i_end;        \
+    }                                   \
 } while (0)
 
 static int read_input(BITS_TYPE *p) {
@@ -187,15 +187,15 @@ static int read_input(BITS_TYPE *p) {
     /* we might overrun the input stream by asking for bits we don't use,
      * so fake 2 more bytes at the end of input */
     if (read == 0) {
-	if (p->input_end) {
-	    D(("out of input bytes"))
-	    return p->error = MSPACK_ERR_READ;
-	}
-	else {
-	    read = 2;
-	    p->inbuf[0] = p->inbuf[1] = 0;
-	    p->input_end = 1;
-	}
+        if (p->input_end) {
+            D(("out of input bytes"))
+            return p->error = MSPACK_ERR_READ;
+        }
+        else {
+            read = 2;
+            p->inbuf[0] = p->inbuf[1] = 0;
+            p->input_end = 1;
+        }
     }
 
     /* update i_ptr and i_end */

data/ext/libmspack/mspack/readhuff.h

@@ -31,32 +31,32 @@
 /* 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);                          \
+    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);                                     \
 } 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 {                        \
+    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));                   \
 } 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 {                         \
+    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));                   \
 } while (0)
 #endif
 
@@ -76,7 +76,7 @@
  * Returns 0 for OK or 1 for error
  */
 static int make_decode_table(unsigned int nsyms, unsigned int nbits,
-			     unsigned char *length, unsigned short *table)
+                             unsigned char *length, unsigned short *table)
 {
     register unsigned short sym, next_symbol;
     register unsigned int leaf, fill;
@@ -90,27 +90,27 @@ static int make_decode_table(unsigned int nsyms, unsigned int nbits,
 
     /* fill entries for codes short enough for a direct mapping */
     for (bit_num = 1; bit_num <= nbits; bit_num++) {
-	for (sym = 0; sym < nsyms; sym++) {
-	    if (length[sym] != bit_num) continue;
+        for (sym = 0; sym < nsyms; sym++) {
+            if (length[sym] != bit_num) continue;
 #ifdef BITS_ORDER_MSB
-	    leaf = pos;
+            leaf = pos;
 #else
-	    /* reverse the significant bits */
-	    fill = length[sym]; reverse = pos >> (nbits - fill); leaf = 0;
-	    do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill);
+            /* reverse the significant bits */
+            fill = length[sym]; reverse = pos >> (nbits - fill); leaf = 0;
+            do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill);
 #endif
 
-	    if((pos += bit_mask) > table_mask) return 1; /* table overrun */
+            if((pos += bit_mask) > table_mask) return 1; /* table overrun */
 
-	    /* fill all possible lookups of this symbol with the symbol itself */
+            /* fill all possible lookups of this symbol with the symbol itself */
 #ifdef BITS_ORDER_MSB
-	    for (fill = bit_mask; fill-- > 0;) table[leaf++] = sym;
+            for (fill = bit_mask; fill-- > 0;) table[leaf++] = sym;
 #else
-	    fill = bit_mask; next_symbol = 1 << bit_num;
-	    do { table[leaf] = sym; leaf += next_symbol; } while (--fill);
+            fill = bit_mask; next_symbol = 1 << bit_num;
+            do { table[leaf] = sym; leaf += next_symbol; } while (--fill);
 #endif
-	}
-	bit_mask >>= 1;
+        }
+        bit_mask >>= 1;
     }
 
     /* exit with success if table is now complete */
@@ -119,11 +119,11 @@ static int make_decode_table(unsigned int nsyms, unsigned int nbits,
     /* mark all remaining table entries as unused */
     for (sym = pos; sym < table_mask; sym++) {
 #ifdef BITS_ORDER_MSB
-	table[sym] = 0xFFFF;
+        table[sym] = 0xFFFF;
 #else
-	reverse = sym; leaf = 0; fill = nbits;
-	do { leaf <<= 1; leaf |= reverse & 1; reverse >>= 1; } while (--fill);
-	table[leaf] = 0xFFFF;
+        reverse = sym; leaf = 0; fill = nbits;
+        do { leaf <<= 1; leaf |= reverse & 1; reverse >>= 1; } while (--fill);
+        table[leaf] = 0xFFFF;
 #endif
     }
 
@@ -137,33 +137,33 @@ static int make_decode_table(unsigned int nsyms, unsigned int nbits,
     bit_mask = 1 << 15;
 
     for (bit_num = nbits+1; bit_num <= HUFF_MAXBITS; bit_num++) {
-	for (sym = 0; sym < nsyms; sym++) {
-	    if (length[sym] != bit_num) continue;
+        for (sym = 0; sym < nsyms; sym++) {
+            if (length[sym] != bit_num) continue;
             if (pos >= table_mask) return 1; /* table overflow */
 
 #ifdef BITS_ORDER_MSB
-	    leaf = pos >> 16;
+            leaf = pos >> 16;
 #else
-	    /* leaf = the first nbits of the code, reversed */
-	    reverse = pos >> 16; leaf = 0; fill = nbits;
-	    do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill);
+            /* leaf = the first nbits of the code, reversed */
+            reverse = pos >> 16; leaf = 0; fill = nbits;
+            do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill);
 #endif
-	    for (fill = 0; fill < (bit_num - nbits); fill++) {
-		/* if this path hasn't been taken yet, 'allocate' two entries */
-		if (table[leaf] == 0xFFFF) {
-		    table[(next_symbol << 1)     ] = 0xFFFF;
-		    table[(next_symbol << 1) + 1 ] = 0xFFFF;
-		    table[leaf] = next_symbol++;
-		}
-
-		/* follow the path and select either left or right for next bit */
-		leaf = table[leaf] << 1;
-		if ((pos >> (15-fill)) & 1) leaf++;
-	    }
-	    table[leaf] = sym;
-	    pos += bit_mask;
-	}
-	bit_mask >>= 1;
+            for (fill = 0; fill < (bit_num - nbits); fill++) {
+                /* if this path hasn't been taken yet, 'allocate' two entries */
+                if (table[leaf] == 0xFFFF) {
+                    table[(next_symbol << 1)     ] = 0xFFFF;
+                    table[(next_symbol << 1) + 1 ] = 0xFFFF;
+                    table[leaf] = next_symbol++;
+                }
+
+                /* follow the path and select either left or right for next bit */
+                leaf = table[leaf] << 1;
+                if ((pos >> (15-fill)) & 1) leaf++;
+            }
+            table[leaf] = sym;
+            pos += bit_mask;
+        }
+        bit_mask >>= 1;
     }
 
     /* full table? */