/*+
************************************************************************
****  C A N A D I A N   A S T R O N O M Y   D A T A   C E N T R E  *****
*
*   Module Name:	press/src/gzip_inflate.c
*
*   Purpose:
*	Contains the gzip_inflate routine for gzip.
*
*	gzip_inflate.c -- Not copyrighted 1992 by Mark Adler
*	version c10p1, 10 January 1993
*
*	You can do whatever you like with this source file, though I would
*	prefer that if you modify it and redistribute it that you include
*	comments to that effect with your name and the date.  Thank you.
*	[The history has been moved to the file ChangeLog.]
*
*
*	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 deals with some chunk of data at a time, and
*	decides which method to use on a chunk-by-chunk basis.  A chunk might
*	typically be 32K or 64K.  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 is compressible, then either the fixed or dynamic methods
*	are used.  In the dynamic method, the compressed data is 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 codes 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.
* 
*	The Huffman codes themselves are decoded using a mutli-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.
*
*
*   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.  Similarly, 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.
*
*   Routines:
*	type	routine		: Brief description.
*	type	routine		: Brief description.
*	type	routine		: Brief description.
*
*   Date		: mmm dd, 1993
*
*   SCCS data		: @(#)
*	Module Name	: gzip_inflate.c
*	Version Number	: 1.5
*	Release Number	: 1
*	Last Updated	: 08/29/97
*
*   Programmer		: your name
*
*   Modification History:
*	97/07/02 SEC  :	Bring up to ANSI Standard.
*	97/08/29 SEC  :	Free window buffer in gzip_inflate().
*	98/10/29 ESO  :	Added "static" keywords to avoid conflict with tclpro libs
*
****  C A N A D I A N   A S T R O N O M Y   D A T A   C E N T R E  *****
************************************************************************
-*/

#include <sys/types.h>
#include <memory.h>

#include "gen_types.h"

#include "press.h"
#include "local_press.h"
#include "gzip.h"

static int huft_free(HUFT *t); /* allan: added proto */

/* 
 * 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). 
 */

/* byte *swindow; (allan: was already defined in gzip.h) */
unsigned	outcnt;		/* current position in window */
#define		flush_output(w) (outcnt=(w),flush_window())


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

static 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 unsigned short cplens[] = {/* 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 unsigned short cplext[] = {/* 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, 99, 99}; /* 99==invalid */
static unsigned short 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};
static unsigned short cpdext[] = {/* 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};



/* 
 * Macros for gzip_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 beginning of a
 * routine that uses these macros from a global bit buffer and count.
 *
 * If we assume that EOB will be the longest code, then we will never
 * ask for bits with NEEDBITS that are beyond the end of the stream.
 * So, NEEDBITS should not read any more bytes than are needed to
 * meet the request.  Then no bytes need to be "returned" to the buffer
 * at the end of the last block.
 *
 * However, this assumption is not true for fixed blocks--the EOB code
 * is 7 bits, but the other literal/length codes can be 8 or 9 bits.
 * (The EOB code is shorter than other codes because fixed blocks are
 * generally short.  So, while a block always has an EOB, many other
 * literal/length codes have a significantly lower probability of
 * showing up at all.)  However, by making the first table have a
 * lookup of seven bits, the EOB code will be found in that first
 * lookup, and so will not require that too many bits be pulled from
 * the stream.
 */

static unsigned long	bb;		/* bit buffer 				*/
static unsigned 	bk;		/* bits in bit buffer 			*/

static unsigned short mask_bits[] = 
{
    0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
};

#define NEXTBYTE()  (byte)get_byte()
#define NEEDBITS(n) {while(k<(n)){b|=((unsigned long)NEXTBYTE())<<k;k+=8;}}
#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
 * is 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 int		lbits = 9;	/* bits in base literal/length lookup table */
static int		dbits = 6;	/* bits in base distance lookup table */


/* 
 * If BMAX needs to be larger than 16, then h and x[] should be ulg. 
 */

#define	BMAX 16		/* maximum bit length of any code (16 for explode) */
#define N_MAX 288	/* maximum number of codes in any set */


static unsigned	hufts;         /* track memory usage */


/*+
************************************************************************
*
*   Synopsis:
*	int	huft_build( b, n, s, d, e, t, m )
*
*   Purpose:
*	Given a list of code lengths and a maximum table size, make a set of
*	tables to decode that set of codes.  Return zero on success, one if
*	the given code set is incomplete (the tables are still built in this
*	case), two if the input is invalid (all zero length codes or an
*	oversubscribed set of lengths), and three if not enough memory.
*
*   Parameters:
*	unsigned	*b	: (mod)	code lengths in bits (all assumed 
*				  <= BMAX) 
*	unsigned	n	: (in)	Number of codes (assumed <= N_MAX)
*	unsigned	s	: (in)	number of simple-valued codes (0..s-1)
*	unsigned short	*d	: (mod)	list of base values for non-simple codes
*	unsigned short	*e	: (mod) list of extra bits for non-simple codes
*	struct huft	**t	: (out)	result: starting table.
*	int		*m	: (mod)	maximum lookup bits, returns actual.
*
*   Values Returned:
*	int	PR_SUCCESS	: Normal completion.
*	int	PR_E_INC_LIT	: Code set is incomplete (the tables are 
*				  still built in this case)
*	int	PR_E_DATA	: The input is invalid (all zero length 
*				  codes or an oversubscribed set of lengths)
*	int	PR_E_MEMORY	: Memory allocation failure.
*
************************************************************************
-*/

static int		huft_build
(
    unsigned	*b,		/* (???) */
    unsigned	n,		/* (???) */
    unsigned	s,		/* (???) */
    unsigned short
    		*d,		/* (???) */
    unsigned short
    		*e,		/* (???) */
    HUFT	**t,		/* (???) */
    int		*m		/* (???) */
)
{
    /* void	pr_format_message(); */

    unsigned	a;		/* counter for codes of length k	*/
    unsigned	c[BMAX+1];	/* bit length count table		*/
    unsigned	f;		/* i repeats in table every f entries	*/
    int		g;		/* maximum code length			*/
    int		h;		/* table level				*/
    unsigned	i;		/* counter, current code		*/
    unsigned	j;		/* counter				*/
    int		k;		/* number of bits in current code	*/
    int		l;		/* bits per table (returned in m)	*/
    unsigned	*p;		/* pointer into c[], b[], or v[]	*/
    HUFT	*q;		/* points to current table		*/
    HUFT	r;		/* table entry for structure assignment	*/
    HUFT	*u[BMAX];	/* table stack				*/
    unsigned	v[N_MAX];	/* values in order of bit length	*/
    int		w;		/* bits before this table == (l * h)	*/
    unsigned	x[BMAX+1];	/* bit offsets, then code stack		*/
    unsigned	*xp;		/* pointer into x			*/
    int		y;		/* number of dummy codes added		*/
    unsigned	z;		/* number of entries in current table	*/


    /* 
     *  Generate counts for each bit length 
     */

    (void) memzero(c, sizeof(c));
    p = b;
    i = n;
    do 
    {
	Tracecv(*p, (stderr, 
		(n-i >= ' ' && n-i <= '~' ? "%c %d\n" : "0x%x %d\n"), 
		n-i, *p));
	c[*p++]++;			/* assume all entries <= BMAX */
    } while (--i);

    if (c[0] == n)			/* null input--all zero length codes */
    {
	*t = (HUFT *) NULL;
	*m = 0;
	return( PR_SUCCESS );
    }


    /* 
     *  Find minimum and maximum length, bound *m by those 
     */

    l = *m;
    for (j = 1; j <= BMAX; j++)
    {
	if (c[j])
	{
	    break;
	}
    }
    k = j;				/* minimum code length */
    if ((unsigned)l < j)
    {
	l = j;
    }
    for (i = BMAX; i; i--)
    {
	if (c[i])
	{
	    break;
	}
    }
    g = i;				/* maximum code length */
    if ((unsigned)l > i)
    {
	l = i;
    }
    *m = l;


    /* 
     *  Adjust last length count to fill out codes, if needed 
     */

    for (y = 1 << j; j < i; j++, y <<= 1)
    {
	if ((y -= c[j]) < 0)
	{
	    pr_format_message( PR_E_DATA );
	    return( PR_E_DATA );	/* bad input: more codes than bits */
	}
    }

    if ((y -= c[i]) < 0)
    {
	pr_format_message( PR_E_DATA );
	return( PR_E_DATA );	/* bad input: more codes than bits */
    }
    c[i] += y;


    /* 
     *  Generate starting offsets into the value table for each length 
     */

    x[1] = j = 0;
    p = c + 1;
    xp = x + 2;
    while (--i)				/* note that i == g from above */
    { 
	*xp++ = (j += *p++);
    }


    /* Make a table of values in order of bit lengths */
    p = b;
    i = 0;
    do 
    {
	if ((j = *p++) != 0)
	{
	    v[x[j]++] = i;
	}
    } while (++i < n);


    /* 
     *  Generate the Huffman codes and for each, make the table entries 
     */
     
    x[0] = i = 0;			/* first Huffman code is zero */
    p = v;				/* grab values in bit order */
    h = -1;				/* no tables yet--level -1 */
    w = -l;				/* bits decoded == (l * h) */
    u[0] = (HUFT *) NULL;		/* just to keep compilers happy */
    q = (HUFT *) NULL;			/* ditto */
    z = 0;				/* ditto */


    /* 
     *  go through the bit lengths (k already is bits in shortest code) 
     */

    for (; k <= g; k++)
    {
	a = c[k];
	while (a--)
	{
	    /*
	     * here i is the Huffman code of length k bits for value *p
	     * make tables up to required level
	     */

	    while (k > w + l)
	    {
		h++;
		w += l;                 /* previous table always l bits */

		/* 
		 *  compute minimum size table less than or equal to l bits 
		 */
					/* upper limit on table size */
		z = (z = g - w) > (unsigned)l ? l : z;     
					/* try a k-w bit table */
		if ((f = 1 << (j = k - w)) > a + 1)
		{			/* too few codes for k-w bit table */
		    f -= a + 1;		/* deduct codes from patterns left */
		    xp = c + k;
		    while (++j < z)	/* try smaller tables up to z bits */
		    {
			if ((f <<= 1) <= *++xp)
			{
			    break;	/* enough codes to use up j bits */
			}
			f -= *xp;	/* else deduct codes from patterns */
		    }
		}
		z = 1 << j;		/* table entries for j-bit table */


		/* 
		 *  allocate and link in new table 
		 */

		if ((q = (HUFT *) malloc((z + 1)*sizeof( HUFT ))) 
			== (HUFT *)NULL)
		{
		    if (h)
		    {
			PR_CHECK( huft_free(u[0]));
		    }
		    pr_format_message( PR_E_MEMORY );
		    return( PR_E_MEMORY );	/* not enough memory */
		}
		hufts += z + 1;		/* track memory usage */
		*t = q + 1;		/* link to list for huft_free() */
		*(t = &(q->v.t)) = (HUFT *) NULL;
		u[h] = ++q;		/* table starts after link */


		/* 
		 *  connect to last table, if there is one 
		 */

		if (h)
		{
		    x[h] = i;		/* save pattern for backing up */
		    r.b = (byte)l;	/* bits to dump before this table */
		    r.e = (byte)(16 + j);/* bits in this table */
		    r.v.t = q;		/* pointer to this table */
		    j = i >> (w - l);	/* (get around Turbo C bug) */
		    u[h-1][j] = r;	/* connect to last table */
		}
	    }


	    /* 
	     *  set up table entry in r 
	     */

	    r.b = (byte)(k - w);
	    if (p >= v + n)
	    {
		r.e = 99;		/* out of values--invalid code */
	    }
	    else if (*p < s)
	    {
		r.e = (byte)(*p < 256 ? 16 : 15);/* 256 is end-of-block code */
		r.v.n = (byte)(*p);	/* simple code is just the value */
		p++;			/* one compiler does not like *p++ */
	    }
	    else
	    {
		r.e = (byte)e[*p - s];	/* non-simple--look up in lists */
		r.v.n = d[*p++ - s];
	    }


	    /* 
	     *  fill code-like entries with r 
	     */
	    f = 1 << (k - w);
	    for (j = i >> w; j < z; j += f)
	    {
		q[j] = r;
	    }


	    /* 
	     *  backwards increment the k-bit code i 
	     */

	    for (j = 1 << (k - 1); i & j; j >>= 1)
	    {
		i ^= j;
	    }
	    i ^= j;


	    /* 
	     *  backup over finished tables 
	     */

	    while ((i & ((1 << w) - 1)) != x[h])
	    {
		h--;			/* don't need to update q */
		w -= l;
	    }
	}
    }


    /* 
     * Return true PR_E_INC_LIT if we were given an incomplete table 
     */

    if ( y != 0 && g != 1 )
    {
	pr_format_message( PR_E_INC_LIT );
	return( PR_E_INC_LIT );
    }
    else
    {
	return( PR_SUCCESS );
    }
}

/*+
************************************************************************
*
*   Synopsis:
*	int	huft_free( t )
*
*   Purpose:
*	Free the malloc'ed tables built by huft_build(), which makes a linked
*	list of the tables it made, with the links in a dummy first entry of
*	each table. 
*
*   Parameters:
*	struct huft	*t	: (in)	Table to free.
*
*   Values Returned:
*	int	PR_SUCCESS	: Normal completion.
*
************************************************************************
-*/

static int		huft_free
(
    HUFT	*t		/* ( ??? ) */
)
{
    HUFT	*p;
    HUFT	*q;


    /* 
     *  Go through linked list, freeing from the malloced (t[-1]) address. 
     */

    p = t;
    while (p != (HUFT *) NULL)
    {
	q = (--p)->v.t;
	free((char*)p);
	p = q;
    } 
    return( PR_SUCCESS );
}

/*+
************************************************************************
*
*   Synopsis:
*	int	inflate_codes( tl, td, bl, bd )
*
*   Purpose:
*	gzip_inflate (decompress) the codes in a deflated (compressed) block.
*
*   Parameters:
*	struct huft	*tl	: (in)	literal/length decoder table.
*	struct huft	*td	: (in)  distance decoder table.
*	int		bl	: (in)	Number of bits decoded by tl.
*	int		bd	: (in)	Number of bits decoded by td.
*
*   Values Returned:
*	int	PR_SUCCESS	: Normal completion.
*	int	PR_E_DATA	: Data is undecodable.
*
************************************************************************
-*/

static int		inflate_codes
(
    HUFT	*tl,		/* ( ??? ) */
    HUFT	*td,		/* ( ??? ) */
    int		bl,		/* ( ??? ) */
    int		bd 		/* ( ??? ) */
)
{
    unsigned	e;		/* table entry flag/number of extra bits*/
    unsigned	n, d;		/* length and index for copy		*/
    unsigned	w;		/* current window position		*/
    HUFT	*t;		/* pointer to table entry		*/
    unsigned	ml, md;		/* masks for bl and bd bits		*/
    unsigned long	
    		b;		/* bit buffer				*/
    unsigned	k;		/* number of bits in bit buffer		*/


    /* 
     *  make local copies of globals 
     */

    b = bb;			/* initialize bit buffer */
    k = bk;
    w = outcnt;			/* initialize window position */


    /* 
     *  inflate the coded data 
     */

    ml = mask_bits[bl];		/* precompute masks for speed */
    md = mask_bits[bd];
    for (;;)			/* do until end of block */
    {
	NEEDBITS((unsigned)bl)
	if ((e = (t = tl + ((unsigned)b & ml))->e) > 16)
	{
	    do 
	    {
		if (e == 99)
		{
		    pr_format_message( PR_E_DATA );
		    return( PR_E_DATA );
		}
		DUMPBITS(t->b)
		e -= 16;
		NEEDBITS(e)
	    } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16);
	}
	DUMPBITS(t->b)
	if (e == 16)		/* then it's a literal */
	{
	    swindow[w++] = (byte)t->v.n;
	    Tracevv((stderr, "%c", swindow[w-1]));
	    if (w == WSIZE)
	    {
		PR_CHECK( flush_output(w) );
		w = 0;
	    }
	}
	else			/* it's an EOB or a length */
	{
	    /* exit if end of block */
	    if (e == 15)
	    {
		break;
	    }


	    /* 
	     *  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((unsigned)bd)
	    if ((e = (t = td + ((unsigned)b & md))->e) > 16)
	    {
		do {
		if (e == 99)
		{
		    pr_format_message( PR_E_DATA );
		    return( PR_E_DATA );
		}
		DUMPBITS(t->b)
		e -= 16;
		NEEDBITS(e)
		} while ((e = (t = t->v.t + 
			((unsigned)b & mask_bits[e]))->e) > 16);
	    }
	    DUMPBITS(t->b)
	    NEEDBITS(e)
	    d = w - t->v.n - ((unsigned)b & mask_bits[e]);
	    DUMPBITS(e)
	    Tracevv((stderr,"\\[%d,%d]", w-d, n));


	    /* 
	     *  do the copy 
	     */

	    do 
	    {
		n -= (e = (e = WSIZE - 
			((d &= WSIZE-1) > w ? d : w)) > n ? n : e);
#if !defined(NOMEMCPY) && !defined(DEBUG)
		if (w - d >= e)	/* (this test assumes unsigned comparison) */
		{
		    memcpy(swindow + w, swindow + d, e);
		    w += e;
		    d += e;
		}
		else		/* do it slow to avoid memcpy() overlap */
#endif /* !NOMEMCPY */
		{
		    do 
		    {
			swindow[w++] = swindow[d++];
			Tracevv((stderr, "%c", swindow[w-1]));
		    } while (--e);
		}
		if (w == WSIZE)
		{
		    PR_CHECK( flush_output(w) );
		    w = 0;
		}
	    } while (n);
	}
    }


    /* 
     *  restore the globals from the locals 
     */

    outcnt = w;                   /* restore global window pointer */
    bb = b;                       /* restore global bit buffer */
    bk = k;

    /* 
     *  done 
     */

    return( PR_SUCCESS );
}

/*+
************************************************************************
*
*   Synopsis:
*	int	inflate_stored( )
*
*   Purpose:
* 	"decompress" an inflated type 0 (stored) block. 
*
*   Parameters:
*	void
*
*   Values Returned:
*	int	PR_SUCCESS	: Normal completion.
*	int	PR_E_DATA	: An error occured in the data.
*
************************************************************************
-*/

static int		inflate_stored
(
    void
)
{
    /* void		pr_format_message(); */

    unsigned		n;	/* number of bytes in block		*/
    unsigned		w;	/* current window position		*/
    unsigned long	b;	/* bit buffer				*/
    unsigned		k;	/* number of bits in bit buffer		*/


    /* 
     *  make local copies of globals 
     */

    b = bb;                       /* initialize bit buffer */
    k = bk;
    w = outcnt;                   /* 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 ) )
    {
	/*
	 *  An error in the compressed data.
	 */

	pr_format_message( PR_E_DATA );
	return( PR_E_DATA );
    }
    DUMPBITS(16)


    /* 
     *  read and output the compressed data 
     */
    while (n--)
    {
	NEEDBITS(8)
	swindow[w++] = (byte)b;
	if (w == WSIZE)
	{
	    PR_CHECK( flush_output( w ) );
	    w = 0;
	}
	DUMPBITS(8)
    }


    /* 
     *  restore the globals from the locals 
     */

    outcnt = w;                   /* restore global window pointer */
    bb = b;                       /* restore global bit buffer */
    bk = k;
    return( PR_SUCCESS );
}

/*+
************************************************************************
*
*   Synopsis:
*	int	inflate_fixed()
*
*   Purpose:
*	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. 
*
*   Parameters:
*	void
*
*   Values Returned:
*	int	PR_SUCCESS	: Normal completion.
*
************************************************************************
-*/

static int 		inflate_fixed
(
    void
)
{
    int		i;		/* temporary variable			*/
    HUFT	*tl;		/* literal/length code table		*/
    HUFT	*td;		/* distance code table			*/
    int		bl;		/* lookup bits for tl			*/
    int		bd;		/* lookup bits for td			*/
    unsigned	l[288];		/* length list for huft_build		*/


    /* 
     *  set up 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++)          /* make a complete, but wrong code set */
    {
	l[i] = 8;
    }
    bl = 7;
    PR_CHECK( huft_build(l, 288, 257, cplens, cplext, &tl, &bl));


    /* 
     *  set up distance table 
     */

    for (i = 0; i < 30; i++)      /* make an incomplete code set */
    {
	l[i] = 5;
    }
    bd = 5;
    i = huft_build( l, 30, 0, cpdist, cpdext, &td, &bd );
    if ( i != PR_SUCCESS && i != PR_E_INC_LIT )
    {
	PR_CHECK( huft_free(tl) );
	return i;
    }


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

    PR_CHECK( inflate_codes(tl, td, bl, bd));


    /* 
     *  free the decoding tables, return 
     */

    PR_CHECK( huft_free(tl) );
    PR_CHECK( huft_free(td) );

    return( PR_SUCCESS );
}

/*+
************************************************************************
*
*   Synopsis:
*	int	inflate_dynamic()
*
*   Purpose:
*	decompress an inflated type 2 (dynamic Huffman codes) block. 
*
*   Parameters:
*	void
*
*   Values Returned:
*	int	PR_SUCCESS	: Normal completion.
*	int	PR_E_DATA	: Data could not be decompressed.
*
************************************************************************
-*/

static int		inflate_dynamic
(
    void
)
{
    /* void	pr_format_message(); */

    int		i;		/* temporary variables 			*/
    unsigned	j;
    unsigned	l;		/* last length 				*/
    unsigned	m;		/* mask for bit lengths table		*/
    unsigned	n;		/* number of lengths to get		*/
    HUFT	*tl;		/* literal/length code table		*/
    HUFT	*td;		/* distance code table			*/
    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		*/
#ifdef PKZIP_BUG_WORKAROUND
    unsigned	ll[288+32];	/* literal/length and distance code lengths */
#else
    unsigned	ll[286+30];	/* literal/length and distance code lengths */
#endif
    unsigned	long b;		/* bit buffer				*/
    unsigned	k;		/* number of bits in bit buffer		*/


    /* 
     *  make local bit buffer
     */

    b = bb;
    k = bk;


    /* 
     * 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 > 288 || nd > 32)
#else
    if (nl > 286 || nd > 30)
#endif
    {
	/*
	 *  Bad lengths.
	 */

	pr_format_message( PR_E_DATA );
	return( PR_E_DATA );
    }


    /* 
     *  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;
    if ( ( i = huft_build( ll, 19, 19, NULL, NULL, &tl, &bl ) ) != 
	    PR_SUCCESS )
    {
	if ( i == PR_E_INC_LIT )
	{
	    PR_CHECK( huft_free(tl) );
	}
	return i;                   /* 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)
	    {
		pr_format_message( PR_E_DATA );
		return( PR_E_DATA );
	    }
	    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)
	    {
		pr_format_message( PR_E_DATA );
		return( PR_E_DATA );
	    }
	    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)
	    {
		pr_format_message( PR_E_DATA );
		return( PR_E_DATA );
	    }
	    while (j--)
	    {
		ll[i++] = 0;
	    }
	    l = 0;
	}
    }


    /* 
     *  free decoding table for trees 
     */

    PR_CHECK( huft_free(tl) );


    /* 
     *  restore the global bit buffer 
     */

    bb = b;
    bk = k;


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

    bl = lbits;
    if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != PR_SUCCESS)
    {
	if ( i == PR_E_INC_LIT ) 
	{
	    PR_CHECK( huft_free(tl) );
	}
	return i;                   /* incomplete code set */
    }
    bd = dbits;
    if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 
	    PR_SUCCESS)
    {
	if (i == PR_E_INC_LIT ) 
	{
#ifdef PKZIP_BUG_WORKAROUND
	    i = 0;
	}
#else
	    PR_CHECK( huft_free(td) );
	}
	PR_CHECK( huft_free(tl) );
	return( i );                   /* incomplete code set */
#endif
    }


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

    PR_CHECK( inflate_codes(tl, td, bl, bd));


    /* 
     *  free the decoding tables, return 
     */

    PR_CHECK( huft_free(tl) );
    PR_CHECK( huft_free(td) );

    return( PR_SUCCESS );
}

/*+
************************************************************************
*
*   Synopsis:
*	static int	inflate_block( e )
*
*   Purpose:
*	decompress an inflated block
*
*   Parameters:
*	boolean	e		: (out)	End flag.
*
*   Values Returned:
*	int	PR_SUCCESS	: Normal completion.
*
************************************************************************
-*/

static int	inflate_block
( 
    boolean		*e	/* (???) */
)
{
    unsigned		t;	/* block type 				*/
    unsigned long	b;	/* bit buffer 				*/
    unsigned		k;	/* number of bits in bit buffer 	*/


    /* 
     * make local bit buffer 
     */

    b = bb;
    k = bk;


    /* 
     * read in last block bit 
     */

    NEEDBITS(1)
    *e = (int)b & 1;
    DUMPBITS(1)


    /* 
     * read in block type 
     */

    NEEDBITS(2)
    t = (unsigned)b & 3;
    DUMPBITS(2)


    /* 
     * restore the global bit buffer 
     */

    bb = b;
    bk = k;


    /* 
     * inflate that block type 
     */

    if ( t == 2 )
    {
	return( inflate_dynamic() );
    }
    else if ( t == 0 )
    {
	return( inflate_stored() );
    }
    else if ( t == 1 )
    {
	return( inflate_fixed() );
    }


    /* 
     * bad block type 
     */

    pr_format_message( PR_E_BLOCK, t );
    return( PR_E_BLOCK );
}

/*+
************************************************************************
*
*   Synopsis:
*	int	gzip_inflate()
*
*   Purpose:
*	Decompress an inflated entry.
*
*   Parameters:
*	void
*
*   Values Returned:
*	int	PR_SUCCESS	: Normal completion.
*	int	PR_E_MEMORY	: Memory alloation failure.
*
************************************************************************
-*/

int		gzip_inflate
(
    void
)
{
    /* static int	inflate_block(); */

    boolean	e;		/* last block flag 			*/
    unsigned	h;		/* maximum struct huft's malloc'ed	*/


    /* 
     * initialize window, bit buffer 
     */

    outcnt = 0;
    bk = 0;
    bb = 0;
    PR_CHECK_NULL(swindow = byte_alloc( WSIZE ) );


    /* 
     * decompress until the last block 
     */

    h = 0;
    do 
    {
	hufts = 0;
	PR_CHECK( inflate_block( &e ) );
	if (hufts > h)
	{
	    h = hufts;
	}
    } while ( !e );


    /* 
     * Undo too much lookahead. The next read will be byte aligned so we
     * can discard unused bits in the last meaningful byte.
     */

    while ( bk >= 8 ) 
    {
	bk -= 8;
	inptr--;
    }


    /* 
     * flush out window, free memory allocated to window.  
     */

    PR_CHECK( flush_output( outcnt ) );
    gen_free( swindow );


    return( PR_SUCCESS );
}
