Subversion Repositories autosfx

#include "stdafx.h"

#pragma hdrstop

#include <stdio.h>

#include "UnzInf.h"

#include "dz_errs.h"

#undef _DZ_FILE_

#define _DZ_FILE_ DZ_UINFLATE_CPP

/*

  Inflate.c -

  Copyright (c) 1990-2007 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2007-Mar-4 or later

  (the contents of which are also included in zip.h) for terms of use.

  If, for some reason, all these files are missing, the Info-ZIP license

  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html

  parts Copyright (C) 1997 Mike White, Eric W. Engler

************************************************************************

 Copyright (C) 2009, 2010  by Russell J. Peters, Roger Aelbrecht

   This file is part of TZipMaster Version 1.9.

    TZipMaster is free software: you can redistribute it and/or modify

    it under the terms of the GNU Lesser General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    TZipMaster is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License

    along with TZipMaster.  If not, see <http://www.gnu.org/licenses/>.

    contact: problems@delphizip.org (include ZipMaster in the subject).

    updates: http://www.delphizip.org

    DelphiZip maillist subscribe at http://www.freelists.org/list/delphizip

************************************************************************/

/* inflate.c -- put in the public domain by Mark Adler

 * This version modified by Chris Vleghert and Eric W. Engler

 * for BCB/Delphi Zip, Jun 18, 2000.

 */

/* Inflate deflated (PKZIP's method 8 compressed) data.  The compression

 * method searches for as much of the current string of bytes (up to a

 * length of 258) in the previous 32K bytes.  If it doesn't find any

 * matches (of at least length 3), it codes the next byte.  Otherwise, it

 * codes the length of the matched string and its distance backwards from

 * the current position.  There is a single Huffman code that codes both

 * single bytes (called "literals") and match lengths.  A second Huffman

 * code codes the distance information, which follows a length code.  Each

 * length or distance code actually represents a base value and a number

 * of "extra" (sometimes zero) bits to get to add to the base value.  At

 * the end of each deflated block is a special end-of-block (EOB) literal/

 * length code.  The decoding process is basically: get a literal/length

 * code; if EOB then done; if a literal, emit the decoded byte; if a

 * length then get the distance and emit the referred-to bytes from the

 * sliding window of previously emitted data.

 *

 * There are (currently) three kinds of inflate blocks: stored, fixed, and

 * dynamic.  The compressor outputs a chunk of data at a time and decides

 * which method to use on a chunk-by-chunk basis.  A chunk might typically

 * be 32K to 64K, uncompressed.  If the chunk is uncompressible, then the

 * "stored" method is used.  In this case, the bytes are simply stored as

 * is, eight bits per byte, with none of the above coding.  The bytes are

 * preceded by a count, since there is no longer an EOB code.

 *

 * If the data are compressible, then either the fixed or dynamic methods

 * are used.  In the dynamic method, the compressed data are preceded by

 * an encoding of the literal/length and distance Huffman codes that are

 * to be used to decode this block.  The representation is itself Huffman

 * coded, and so is preceded by a description of that code.  These code

 * descriptions take up a little space, and so for small blocks, there is

 * a predefined set of codes, called the fixed codes.  The fixed method is

 * used if the block ends up smaller that way (usually for quite small

 * chunks); otherwise the dynamic method is used.  In the latter case, the

 * codes are customized to the probabilities in the current block and so

 * can code it much better than the pre-determined fixed codes can.

 *

 * The Huffman codes themselves are decoded using a multi-level table

 * lookup, in order to maximize the speed of decoding plus the speed of

 * building the decoding tables.  See the comments below that precede the

 * lbits and dbits tuning parameters.

 * GRR:  return values(?)

 *         0  OK

 *         1  incomplete table

 *         2  bad input

 *         3  not enough memory

 */

/*

 * Notes beyond the 1.93a appnote.txt:

 *  1. Distance pointers never point before the beginning of the output

 *     stream.

 *  2. Distance pointers can point back across blocks, up to 32k away.

 *  3. There is an implied maximum of 7 bits for the bit length table and

 *     15 bits for the actual data.

 *  4. If only one code exists, then it is encoded using one bit.  (Zero

 *     would be more efficient, but perhaps a little confusing.)  If two

 *     codes exist, they are coded using one bit each (0 and 1).

 *  5. There is no way of sending zero distance codes--a dummy must be

 *     sent if there are none.  (History: a pre 2.0 version of PKZIP would

 *     store blocks with no distance codes, but this was discovered to be

 *     too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow

 *     zero distance codes, which is sent as one code of zero bits in

 *     length.

 *  6. There are up to 286 literal/length codes.  Code 256 represents the

 *     end-of-block.  Note however that the static length tree defines

 *     288 codes just to fill out the Huffman codes.  Codes 286 and 287

 *     cannot be used though, since there is no length base or extra bits

 *     defined for them.  Similarily, there are up to 30 distance codes.

 *     However, static trees define 32 codes (all 5 bits) to fill out the

 *     Huffman codes, but the last two had better not show up in the data.

 *  7. Unzip can check dynamic Huffman blocks for complete code sets.

 *     The exception is that a single code would not be complete (see #4).

 *  8. The five bits following the block type is really the number of

 *     literal codes sent minus 257.

 *  9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits

 *     (1+6+6).  Therefore, to output three times the length, you output

 *     three codes (1+1+1), whereas to output four times the same length,

 *     you only need two codes (1+3).  Hmm.

 * 10. In the tree reconstruction algorithm, Code = Code + Increment

 *     only if BitLength(i) is not zero.  (Pretty obvious.)

 * 11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)

 * 12. Note: length code 284 can represent 227-258, but length code 285

 *     really is 258.  The last length deserves its own, short code

 *     since it gets used a lot in very redundant files.  The length

 *     258 is special since 258 - 3 (the min match length) is 255.

 * 13. The literal/length and distance code bit lengths are read as a

 *     single stream of lengths.  It is possible (and advantageous) for

 *     a repeat code (16, 17, or 18) to go across the boundary between

 *     the two sets of lengths.

 * 14. The Deflate64 (PKZIP method 9) variant of the compression algorithm

 *     differs from "classic" deflate in the following 3 aspect:

 *     a) The size of the sliding history window is expanded to 64 kByte.

 *     b) The previously unused distance codes #30 and #31 code distances

 *        from 32769 to 49152 and 49153 to 65536.  Both codes take 14 bits

 *        of extra data to determine the exact position in their 16 kByte

 *        range.

 *     c) The last lit/length code #285 gets a different meaning. Instead

 *        of coding a fixed maximum match length of 258, it is used as a

 *        "generic" match length code, capable of coding any length from

 *        3 (min match length + 0) to 65538 (min match length + 65535).

 *        This means that the length code #285 takes 16 bits (!) of uncoded

 *        extra data, added to a fixed min length of 3.

 *     Changes a) and b) would have been transparent for valid deflated

 *     data, but change c) requires to switch decoder configurations between

 *     Deflate and Deflate64 modes.

 */

#define PKZIP_BUG_WORKAROUND    /* PKZIP 1.93a problem--live with it */

/*  inflate.h must supply the uch slide[UWSIZE] array, the void typedef

 *  (void if (void *) is accepted, else char) and the NEXTBYTE,

 *  FLUSH() and memzero macros.  If the window size is not 32K, it

 *  should also define UWSIZE.  If INFMOD is defined, it can include

 *  compiled functions to support the NEXTBYTE and/or FLUSH() macros.

 *  There are defaults for NEXTBYTE and FLUSH() below for use as

 *  examples of what those functions need to do.  Normally, you would

 *  also want FLUSH() to compute a crc on the data.  inflate.h also

 *  needs to provide these typedefs:

 *      typedef unsigned char  uch;

 *      typedef unsigned short ush;

 *      typedef unsigned long  ulg;

 */

/*

#ifdef USING_MEM_STRMS

#define FLUSH(w)  ((fmem_mode)? MemFlush(Slide, (ulg)(w)) \

                      : flush(Slide, (ulg)(w), 0))

#else */

//#define FLUSH(w)  (flush(Slide, (ulg)(w), 0))

//#endif

//#define NEXTBYTE  (--fincnt >= 0 ? (int)(*finptr++) : readbyte(pG))

#define READBITS(nbits, zdest) { if(nbits>fbits_left) {int temp; fzipeof = 1; \

  while (fbits_left <= 8 *(sizeof(fbitbuf)- 1) && (temp = NEXTBYTE) != EOF) { \

  fbitbuf |= (ulg)temp << fbits_left; fbits_left += 8; fzipeof = 0;}} \

  zdest = (shrint)((ush)fbitbuf & mask_bits[nbits]); fbitbuf >>= nbits; \

  fbits_left -= nbits; }

//#ifndef NEXTBYTE                /* default is to simply get a byte from stdin */

//error NEXTBYTE not defined

////#  define NEXTBYTE getchar()

//#endif

//#ifndef FLUSH                   /* default is to simply write the buffer to stdout */

//error FLUSH not defined

//#  define FLUSH(n) fwrite(Slide, 1, n, stdout) /* return value not used */

//#endif

/* The inflate algorithm uses a sliding 32K byte window on the uncompressed

 * stream to find repeated byte strings.  This is implemented here as a

 * circular buffer.  The index is updated simply by incrementing and then

 * and'ing with 0x7fff (32K-1).

 * It is left to other modules to supply the 32K area.  It is assumed

 * to be usable as if it were declared "uch slide[32768];" or as just

 * "uch *slide;" and then malloc'ed in the latter case.  The definition

 * must be in unzip.h, included above.

 */

#define INVALID_CODE 99

#define IS_INVALID_CODE(c)  ((c) == INVALID_CODE)

/* Tables for deflate from PKZIP's appnote.txt. */

static const unsigned border[]  =

  {      /* Order of the bit length code lengths */

    16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15

  };

static const ush cplens32[]  =

  {   /* Copy lengths for literal codes 257..285 */

    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,

    35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0

  };

/* note: see note #13 above about the 258 in this list. */

static const ush cplens64[] =

  {

    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,

    35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 3, 0, 0

  };

/* For Deflate64, the code 285 is defined differently. */

static const uch cplext32[]  =

  {   /* Extra bits for literal codes 257..285 */

    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,

    3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, INVALID_CODE, INVALID_CODE

  }

  ;                              /* 99==invalid */

static const uch cplext64[] =

  {

    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,

    3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 16, INVALID_CODE, INVALID_CODE

  };

static const ush cpdist[]  =

  {   /* Copy offsets for distance codes 0..29 */

    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,

    257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,

    8193, 12289, 16385, 24577, 32769, 49153

  };

static const uch cpdext32[]  =

  {   /* Extra bits for distance codes */

    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,

    7, 7, 8, 8, 9, 9, 10, 10, 11, 11,

    12, 12, 13, 13, INVALID_CODE, INVALID_CODE

  };

static const uch cpdext64[] =

  {

    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,

    7, 7, 8, 8, 9, 9, 10, 10, 11, 11,

    12, 12, 13, 13, 14, 14

  };

#define MAXLITLENS 288

#define MAXDISTS 32

/* Macros for inflate() bit peeking and grabbing.

 * The usage is:

 *      NEEDBITS(j)

 *      x = b & mask_bits[j];

 *      DUMPBITS(j)

 * where NEEDBITS makes sure that b has at least j bits in it, and

 * DUMPBITS removes the bits from b.  The macros use the variable k

 * for the number of bits in b.  Normally, b and k are register

 * variables for speed and are initialized at the begining of a

 * routine that uses these macros from a global bit buffer and count.

 *

 * In order to not ask for more bits than there are in the compressed

 * stream, the Huffman tables are constructed to only ask for just

 * enough bits to make up the end-of-block code (value 256).  Then no

 * bytes need to be "returned" to the buffer at the end of the last

 * block.  See the huft_build() routine.

 */

//#  define NEXTBYTE  (--fincnt >= 0 ? (int)(*finptr++) : readbyte())

#ifndef CHECK_EOF

#  define CHECK_EOF             /* default as of 5.13/5.2 */

#endif

#ifndef CHECK_EOF

#  define NEEDBITS(n) {while(k < (n)) {b |= ((ulg)NEXTBYTE) << k;k += 8;} }

#else

//#  define NEEDBITS(n) {while(k < (n)) {int c = NEXTBYTE; if (c == EOF) return 1;

//    b |= ((ulg)c) << k; k += 8;} }

#ifdef TRACE_INFLATE

#  define NEEDBITS(n) {while((int)k < (int)(n)) {int c = NEXTBYTE; if (c == EOF){\

     if ((int)k>=0)break;retval=1; \

     if (Verbose < 0) Notify(ITRACE, "eos %s", __LINE__); goto fini;} \

    b |= ((ulg)c) << k; k += 8;} }

#else

#  define NEEDBITS(n) {while((int)k < (int)(n)) {int c = NEXTBYTE; if (c == EOF){\

     if ((int)k>=0)break;retval=1;goto fini;} \

    b |= ((ulg)c) << k; k += 8;} }

#endif

#endif /* Piet Plomp:  change "return 1" to "break" */

#define DUMPBITS(n) {b >>= (n); k -= (n);}

/* Huffman code decoding is performed using a multi-level table lookup.

 * The fastest way to decode is to simply build a lookup table whose

 * size is determined by the longest code.  However, the time it takes

 * to build this table can also be a factor if the data being decoded

 * are not very long.  The most common codes are necessarily the

 * shortest codes, so those codes dominate the decoding time, and hence

 * the speed.  The idea is you can have a shorter table that decodes the

 * shorter, more probable codes, and then point to subsidiary tables for

 * the longer codes.  The time it costs to decode the longer codes is

 * then traded against the time it takes to make longer tables.

 *

 * This results of this trade are in the variables lbits and dbits

 * below.  lbits is the number of bits the first level table for literal/

 * length codes can decode in one step, and dbits is the same thing for

 * the distance codes.  Subsequent tables are also less than or equal to

 * those sizes.  These values may be adjusted either when all of the

 * codes are shorter than that, in which case the longest code length in

 * bits is used, or when the shortest code is *longer* than the requested

 * table size, in which case the length of the shortest code in bits is

 * used.

 *

 * There are two different values for the two tables, since they code a

 * different number of possibilities each.  The literal/length table

 * codes 286 possible values, or in a flat code, a little over eight

 * bits.  The distance table codes 30 possible values, or a little less

 * than five bits, flat.  The optimum values for speed end up being

 * about one bit more than those, so lbits is 8+1 and dbits is 5+1.

 * The optimum values may differ though from machine to machine, and

 * possibly even between compilers.  Your mileage may vary.

 */

static const int lbits = 9;     /* bits in base literal/length lookup table */

static const int dbits = 6;     /* bits in base distance lookup table       */

//#  define NEXTBYTE  (--fincnt >= 0 ? (int)(*finptr++) : readbyte())

int huft_free(struct huft *t);

/* ===========================================================================

 * inflate (decompress) the codes in a deflated (compressed) block.

 * Return an error code or zero if it all goes ok.

        *tl, *td :: Literal/length and distance decoder tables.

         bl, bd  :: Number of bits decoded by tl[] and td[].

 */

int UnzInf::inflate_codes(struct huft *tl, struct huft *td, int bl, int bd)

{

  register unsigned e;          /* table entry flag/number of extra bits  */

  unsigned n, d;                /* length and index for copy */

  unsigned w;                   /* current window position */

  struct huft *t;               /* pointer to table entry */

  unsigned ml, md;              /* masks for bl and bd bits */

  register ulg b;               /* bit buffer   */

  register unsigned k;          /* number of bits in bit buffer   */

  int retval = 0;

#ifdef TRACE_INFLATE

  if (Verbose < 0)

    Notify(ITRACE, _T("inflate codes"));

#endif

  /* make local copies of globals */

  b = fbb;                   /* initialize bit buffer    */

  k = fbk;

  w = fwp;                   /* initialize window position */

  /* inflate the coded data */

  ml = mask_bits[bl];           /* precompute masks for speed */

  md = mask_bits[bd];

  while (1)

  {                   /* do until end of block   */

    NEEDBITS((unsigned)  bl)

    t = tl + ((unsigned)  b & ml);

    while (1)

    {

      DUMPBITS(t->b)

      if ((e = t->e) == 32)     /* then it's a literal */

      {

        Slide[w++] = (uch)t->v.n;

//#ifdef USE_STRM_OUTPUT

//              if (fredirect_data && !(w % 0x8000))    // RCV1.6019

//              {

//                // bump up progress bar

//                UserProgress(0x8000);

//              }

//#endif

                if (w == wsize)

                {

//                if ((retval = FLUSH(w)) != 0)

                  if ((retval = flush(Slide, (ulg)(w), 0)) != 0)

                        goto fini;

          w = 0;

        }

        break;

      }

      if (e < 31)               /* then it's a length */

      {

        /* get length of block to copy */

        NEEDBITS(e)

        n = t->v.n + ((unsigned)b & mask_bits[e]);

        DUMPBITS(e)

        /* decode distance of block to copy */

        NEEDBITS(bd)

        t = td + ((unsigned)b & md);

        while (1)

        {

          DUMPBITS(t->b)

          if ((e = t->e) < 32)

            break;

          if (IS_INVALID_CODE(e))

            return 1;

          e &= 31;

          NEEDBITS(e)

          t = t->v.t + ((unsigned)b & mask_bits[e]);

        }

        NEEDBITS(e)

        d = (unsigned)w - t->v.n - ((unsigned)b & mask_bits[e]);

        DUMPBITS(e)

        /* do the copy */

        do

        {

//#ifdef USE_STRM_OUTPUT

//                if (fredirect_data && !fUseInStream)

//                {       /* &= w/ wsize unnecessary & wrong if redirect      */

//                      if (d >= wsize)

//                        return 1;   // invalid compression data

//                      e = (unsigned)(wsize - (d > (unsigned)w ? (ulg)d : w));

//                }

//                else

//#endif

            e = (unsigned)(wsize -

                           ((d &= (unsigned)(wsize-1)) > (unsigned)w ?

                            (ulg)d : w));

          if ((ulg)e > n)

            e = (unsigned)n;

          n -= e;

//#ifndef NOMEMCPY

                  if (w - d >= e)

          {       /* (this test assumes unsigned comparison)              */

            memcpy(Slide + w, Slide + d, e);

//#ifdef USE_STRM_OUTPUT

//                      if (fredirect_data && ((w + e)  / 0x8000 - w / 0x8000))      // RCV1.6022

//                      {

//                        // bump up progress bar

//                        UserProgress(0x8000);

//                      }

//#endif

            w += e;

            d += e;

          }

          else                    /* do it slowly to avoid memcpy() overlap */

//#  endif /* !NOMEMCPY */

                        do

            {

              Slide[w++]  = Slide[d++];

//# ifdef USE_STRM_OUTPUT

//                        if (fredirect_data && !(w % 0x8000))      // RCV1.6019 1.6022

//                        {

//                              // bump up progress bar

//                              UserProgress(0x8000);

//                        }

//#  endif

            }

            while (--e);

          if (w == wsize)

                  {

//                      if ((retval = FLUSH(w)) != 0)

                        if ((retval = flush(Slide, (ulg)(w), 0)) != 0)

              goto fini;

            w = 0;

          }

        }

        while (n);

        break;

      }

      if (e == 31)              /* it's the EOB signal */

      {

        /* sorry for this goto, but we have to exit two loops at once */

        goto clean1;

      }

      if (IS_INVALID_CODE(e))

        return 1;

      e &= 31;

      NEEDBITS(e)

      t = t->v.t + ((unsigned)b & mask_bits[e]);

    }

  }

clean1:

  /* restore the globals from the locals */

  fwp = w;                   /* restore global window pointer */

  fbb = b;                   /* restore global bit buffer */

  fbk = k;

fini:

#ifdef TRACE_INFLATE

  if (Verbose < 0)

    Notify(ITRACE, _T("inflate_codes returning %d"), retval);

#endif

  return retval;

}

/* ===========================================================================

 * "decompress" an inflated type 0 (stored) block.

 */

int UnzInf::inflate_stored(void)

{

  unsigned n;                   /* number of bytes in block    */

  unsigned w;                   /* current window position   */

  register ulg b;               /* bit buffer      */

  register unsigned k;          /* number of bits in bit buffer   */

  int retval = 0;

  /* make local copies of globals */

#ifdef TRACE_INFLATE

  if (Verbose < 0)

    Notify(ITRACE, _T("extracting files from stored block"));

#endif

  b = fbb;                   /* initialize bit buffer      */

  k = fbk;

  w = fwp;                   /* initialize window position */

  /* go to byte boundary */

  n = k & 7;

  DUMPBITS(n);

  /* get the length and its complement */

  NEEDBITS(16)

  n = ((unsigned)  b & 0xffff);

  DUMPBITS(16)

  NEEDBITS(16)

  if (n != (unsigned)((~b)  & 0xffff))

  {

#ifdef TRACE_INFLATE

  if (Verbose < 0)

    Notify(ITRACE, _T("error in compressed stored data"));

#endif

    return 1;                   /* error in compressed data */

  }

  DUMPBITS(16)

  /* read and output the compressed data */

  while (n--)

  {

    NEEDBITS(8)

    Slide[w++]  = (uch)  b;

//# ifdef USE_STRM_OUTPUT

//      if (fredirect_data && !(w % 0x8000))      // RCV1.6019

//      {

//        // bump up progress bar

//        UserProgress(0x8000);

//      }

//#  endif

    if (w == wsize)

        {

//        if ((retval = FLUSH(w)) != 0)

          if ((retval = flush(Slide, (ulg)(w), 0)) != 0)

        goto fini;

      w = 0;

    }

    DUMPBITS(8)

  }

  /* restore the globals from the locals */

  fwp = w;                   /* restore global window pointer */

  fbb = b;                   /* restore global bit buffer */

  fbk = k;

fini:

  return retval;

}

/* ===========================================================================

 * decompress an inflated type 1 (fixed Huffman codes) block.  We should

 * either replace this with a custom decoder, or at least precompute the

 * Huffman tables.

 */

int UnzInf::inflate_fixed(void)

{

  /* if first time, set up tables for fixed blocks */

#ifdef TRACE_INFLATE

  if (Verbose < 0)

    Notify(ITRACE, _T("literal block"));

#endif

  if (ffixed_tl == (struct huft *)  NULL)

  {

    int i;                      /* temporary variable                      */

    unsigned l[288];            /* length list for huft_build */

    /* literal table */

    for (i = 0; i < 144; i++)

      l[i]  = 8;

    for (; i < 256; i++)

      l[i]  = 9;

    for (; i < 280; i++)

      l[i]  = 7;

    for (; i < 288; i++)

      l[i]  = 8;                 /* make a complete, but wrong code set */

    ffixed_bl = 7;

    if ((i =

           huft_build(l, 288, 257, fcplens, fcplext, &ffixed_tl,

                      &ffixed_bl))  != 0)

    {

      ffixed_tl = (struct huft *)  NULL;

      return i;

    }

    /* distance table */

    for (i = 0; i < MAXDISTS; i++)

      l[i]  = 5;                 /* make an incomplete code set */

    ffixed_bd = 5;

    if ((i =

           huft_build(l, MAXDISTS, 0, cpdist, fcpdext, &ffixed_td,

                      &ffixed_bd))  > 1)

    {

      huft_free(ffixed_tl);

      ffixed_tl = (struct huft *)  NULL;

      return i;

    }

  }

  /* Decompress until an end-of-block code. */

  return inflate_codes(ffixed_tl, ffixed_td, ffixed_bl,

                       ffixed_bd)  != 0;

}

/* ===========================================================================

 * decompress an inflated type 2 (dynamic Huffman codes) block.

 */

int UnzInf::inflate_dynamic(void)

{

  int i;                        /* temporary variables    */

  unsigned j;

  unsigned l;                   /* last length     */

  unsigned m;                   /* mask for bit lengths table   */

  unsigned n;                   /* number of lengths to get   */

  int bl;                       /* lookup bits for tl      */

  int bd;                       /* lookup bits for td      */

  unsigned nb;                  /* number of bit length codes     */

  unsigned nl;                  /* number of literal/length codes   */

  unsigned nd;                  /* number of distance codes    */

  int retval;// =0;

  struct huft *tl = NULL;              /* literal/length code table     */

  struct huft *td = NULL;              /* distance code table         */

//#ifdef PKZIP_BUG_WORKAROUND

  unsigned ll[288 + MAXDISTS]; /* literal/length and distance code lengths */

//#else

//  unsigned ll[286 + 30];        /* literal/length and distance code lengths */

//#endif

  register ulg b;               /* bit buffer */

  register unsigned k;          /* number of bits in bit buffer */

  /* make local bit buffer */

#ifdef TRACE_INFLATE

  if (Verbose < 0)

    Notify(ITRACE, _T("in inflate_dynamic"));

#endif

  b = fbb;

  k = fbk;

  /* read in table lengths */

  NEEDBITS(5)

  nl = 257 + ((unsigned)  b & 0x1f);   /* number of literal/length codes */

  DUMPBITS(5)

  NEEDBITS(5)

  nd = 1 + ((unsigned)  b & 0x1f);     /* number of distance codes */

  DUMPBITS(5)

  NEEDBITS(4)

  nb = 4 + ((unsigned)  b & 0xf);      /* number of bit length codes */

  DUMPBITS(4)

//#ifdef PKZIP_BUG_WORKAROUND

  if (nl > MAXLITLENS || nd > MAXDISTS)

//#else

//  if (nl > 286 || nd > 30)

//#endif

    return 1;                   /* bad lengths */

  /* read in bit-length-code lengths */

  for (j = 0; j < nb; j++)

  {

    NEEDBITS(3)

    ll[border[j]]  = (unsigned)  b & 7;

    DUMPBITS(3)

  }

  for (; j < 19; j++)

    ll[border[j]]  = 0;

  /* build decoding table for trees--single level, 7 bit lookup */

  bl = 7;

  retval = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl);

  if (bl == 0)

    retval = 1;

  if (retval)

  {

    if (retval == 1)

      huft_free(tl);

    return retval;                   /* incomplete code set */

  }

  /* read in literal and distance code lengths */

  n = nl + nd;

  m = mask_bits[bl];

  i = l = 0;

  while ((unsigned)  i < n)

  {

    NEEDBITS((unsigned)  bl)

    j = (td = tl + ((unsigned)  b & m)) ->b;

    DUMPBITS(j)

    j = td->v.n;

    if (j < 16)                  /* length of code in bits (0..15)       */

      ll[i++]  = l = j;          /* save last length in l         */

    else

      if (j == 16)

      {         /* repeat last length 3 to 6 times */

        NEEDBITS(2)

        j = 3 + ((unsigned)  b & 3);

        DUMPBITS(2)

        if ((unsigned)  i + j > n)

        {

          huft_free(tl);

          return 1;

        }

        while (j--)

          ll[i++]  = l;

      }

      else

        if (j == 17)

        {         /* 3 to 10 zero length codes */

          NEEDBITS(3)

          j = 3 + ((unsigned)  b & 7);

          DUMPBITS(3)

          if ((unsigned)  i + j > n)

          {

            huft_free(tl);

            return 1;

          }

          while (j--)

            ll[i++]  = 0;

          l = 0;

        }

        else

        {                      /* j == 18: 11 to 138 zero length codes */

          NEEDBITS(7)

          j = 11 + ((unsigned)  b & 0x7f);

          DUMPBITS(7)

          if ((unsigned)  i + j > n)

          {

            huft_free(tl);

            return 1;

          }

          while (j--)

            ll[i++]  = 0;

          l = 0;

        }

  }

  /* free decoding table for trees */

  huft_free(tl);

  /* restore the global bit buffer */

  fbb = b;

  fbk = k;

  /* build the decoding tables for literal/length and distance codes */

  bl = lbits;

  retval = huft_build(ll, nl, 257, fcplens, fcplext, &tl, &bl);

  if (bl == 0)

    retval = 1;

  if (retval)

  {

    if (retval == 1 && !fqflag)

    {

      Notify(0, _T("Fatal error: incomplete l - tree"));

      huft_free(tl);

    }

    return retval;                   /* incomplete code set */

  }

  bd = dbits;

  retval = huft_build(ll + nl, nd, 0, cpdist, fcpdext, &td, &bd);

  if (retval == 1)

    retval =0;

  if (bd == 0 && nl > 257)   // lengths but no distances

    retval = 1;

  if (retval)

  {

    if (retval == 1)

    {

      if (!fqflag)

        Notify(0, _T("Fatal Error: incomplete d-tree"));

//#ifdef PKZIP_BUG_WORKAROUND

//                            i = 0;  RCV not used later on why???

//#else

      huft_free(td);

//#endif

    }

//#ifndef PKZIP_BUG_WORKAROUND

    huft_free(tl);

    return retval;                   /* incomplete code set */

//#endif

  }

  /* decompress until an end-of-block code */

  retval = inflate_codes(tl, td, bl, bd);

fini:

  /* free the decoding tables, return */

  huft_free(tl);

  huft_free(td);

#ifdef TRACE_INFLATE

  if (Verbose < 0)

    Notify(ITRACE, _T("inflate_dynamic returning %d"), retval);

#endif

  return retval;

}

/* ===========================================================================

 * decompress an inflated block

        *e :: Last block flag.

 */

int UnzInf::inflate_block(int *e)