Src/zlib-1.1.4/inftrees.c

/* inftrees.c -- generate Huffman trees for efficient decoding
 * Copyright (C) 1995-2002 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h 
 */

#include "zutil.h"
#include "inftrees.h"

#if !defined(BUILDFIXED) && !defined(STDC)
#  define BUILDFIXED   /* non ANSI compilers may not accept inffixed.h */
#endif

const char inflate_copyright[] =
   " inflate 1.1.4 Copyright 1995-2002 Mark Adler ";
/*
  If you use the zlib library in a product, an acknowledgment is welcome
  in the documentation of your product. If for some reason you cannot
  include such an acknowledgment, I would appreciate that you keep this
  copyright string in the executable of your product.
 */
struct internal_state  {int dummy;}; /* for buggy compilers */

/* simplify the use of the inflate_huft type with some defines */
#define exop word.what.Exop
#define bits word.what.Bits


local int huft_build OF((
    uIntf *,            /* code lengths in bits */
    uInt,               /* number of codes */
    uInt,               /* number of "simple" codes */
    const uIntf *,      /* list of base values for non-simple codes */
    const uIntf *,      /* list of extra bits for non-simple codes */
    inflate_huft * FAR*,/* result: starting table */
    uIntf *,            /* maximum lookup bits (returns actual) */
    inflate_huft *,     /* space for trees */
    uInt *,             /* hufts used in space */
    uIntf * ));         /* space for values */

/* Tables for deflate from PKZIP's appnote.txt. */
local const uInt cplens[31] = { /* 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};
        /* see note #13 above about 258 */
local const uInt cplext[31] = { /* 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, 112, 112}; /* 112==invalid */
local const uInt cpdist[30] = { /* 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};
local const uInt cpdext[30] = { /* 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};

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


/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
#define BMAX 15         /* maximum bit length of any code */

local int huft_build(b, n, s, d, e, t, m, hp, hn, v)
uIntf *b;               /* code lengths in bits (all assumed <= BMAX) */
uInt n;                 /* number of codes (assumed <= 288) */
uInt s;                 /* number of simple-valued codes (0..s-1) */
const uIntf *d;         /* list of base values for non-simple codes */
const uIntf *e;         /* list of extra bits for non-simple codes */
inflate_huft * FAR *t;  /* result: starting table */
uIntf *m;               /* maximum lookup bits, returns actual */
inflate_huft *hp;       /* space for trees */
uInt *hn;               /* hufts used in space */
uIntf *v;               /* working area: values in order of bit length */
/* Given a list of code lengths and a maximum table size, make a set of
   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
   if the given code set is incomplete (the tables are still built in this
   case), or Z_DATA_ERROR if the input is invalid. */
{

  uInt a;                       /* counter for codes of length k */
  uInt c[BMAX+1];               /* bit length count table */
  uInt f;                       /* i repeats in table every f entries */
  int g;                        /* maximum code length */
  int h;                        /* table level */
  register uInt i;              /* counter, current code */
  register uInt j;              /* counter */
  register int k;               /* number of bits in current code */
  int l;                        /* bits per table (returned in m) */
  uInt mask;                    /* (1 << w) - 1, to avoid cc -O bug on HP */
  register uIntf *p;            /* pointer into c[], b[], or v[] */
  inflate_huft *q;              /* points to current table */
  struct inflate_huft_s r;      /* table entry for structure assignment */
  inflate_huft *u[BMAX];        /* table stack */
  register int w;               /* bits before this table == (l * h) */
  uInt x[BMAX+1];               /* bit offsets, then code stack */
  uIntf *xp;                    /* pointer into x */
  int y;                        /* number of dummy codes added */
  uInt z;                       /* number of entries in current table */


  /* Generate counts for each bit length */
  p = c;
#define C0 *p++ = 0;
#define C2 C0 C0 C0 C0
#define C4 C2 C2 C2 C2
  C4                            /* clear c[]--assume BMAX+1 is 16 */
  p = b;  i = n;
  do {
    c[*p++]++;                  /* assume all entries <= BMAX */
  } while (--i);
  if (c[0] == n)                /* null input--all zero length codes */
  {
    *t = (inflate_huft *)Z_NULL;
    *m = 0;
    return Z_OK;
  }


  /* 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 ((uInt)l < j)
    l = j;
  for (i = BMAX; i; i--)
    if (c[i])
      break;
  g = i;                        /* maximum code length */
  if ((uInt)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)
      return Z_DATA_ERROR;
  if ((y -= c[i]) < 0)
    return Z_DATA_ERROR;
  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);
  n = x[g];                     /* set n to length of v */


  /* 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] = (inflate_huft *)Z_NULL;        /* just to keep compilers happy */
  q = (inflate_huft *)Z_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 */
        z = g - w;
        z = z > (uInt)l ? l : z;        /* table size upper limit */
        if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */
        {                       /* too few codes for k-w bit table */
          f -= a + 1;           /* deduct codes from patterns left */
          xp = c + k;
          if (j < z)
            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 new table */
        if (*hn + z > MANY)     /* (note: doesn't matter for fixed) */
          return Z_DATA_ERROR;  /* overflow of MANY */
        u[h] = q = hp + *hn;
        *hn += z;

        /* connect to last table, if there is one */
        if (h)
        {
          x[h] = i;             /* save pattern for backing up */
          r.bits = (Byte)l;     /* bits to dump before this table */
          r.exop = (Byte)j;     /* bits in this table */
          j = i >> (w - l);
          r.base = (uInt)(q - u[h-1] - j);   /* offset to this table */
          u[h-1][j] = r;        /* connect to last table */
        }
        else
          *t = q;               /* first table is returned result */
      }

      /* set up table entry in r */
      r.bits = (Byte)(k - w);
      if (p >= v + n)
        r.exop = 128 + 64;      /* out of values--invalid code */
      else if (*p < s)
      {
        r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);     /* 256 is end-of-block */
        r.base = *p++;          /* simple code is just the value */
      }
      else
      {
        r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */
        r.base = 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 */
      mask = (1 << w) - 1;      /* needed on HP, cc -O bug */
      while ((i & mask) != x[h])
      {
        h--;                    /* don't need to update q */
        w -= l;
        mask = (1 << w) - 1;
      }
    }
  }


  /* Return Z_BUF_ERROR if we were given an incomplete table */
  return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
}


int inflate_trees_bits(c, bb, tb, hp, z)
uIntf *c;               /* 19 code lengths */
uIntf *bb;              /* bits tree desired/actual depth */
inflate_huft * FAR *tb; /* bits tree result */
inflate_huft *hp;       /* space for trees */
z_streamp z;            /* for messages */
{
  int r;
  uInt hn = 0;          /* hufts used in space */
  uIntf *v;             /* work area for huft_build */

  if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)
    return Z_MEM_ERROR;
  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL,
                 tb, bb, hp, &hn, v);
  if (r == Z_DATA_ERROR)
    z->msg = (char*)"oversubscribed dynamic bit lengths tree";
  else if (r == Z_BUF_ERROR || *bb == 0)
  {
    z->msg = (char*)"incomplete dynamic bit lengths tree";
    r = Z_DATA_ERROR;
  }
  ZFREE(z, v);
  return r;
}


int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z)
uInt nl;                /* number of literal/length codes */
uInt nd;                /* number of distance codes */
uIntf *c;               /* that many (total) code lengths */
uIntf *bl;              /* literal desired/actual bit depth */
uIntf *bd;              /* distance desired/actual bit depth */
inflate_huft * FAR *tl; /* literal/length tree result */
inflate_huft * FAR *td; /* distance tree result */
inflate_huft *hp;       /* space for trees */
z_streamp z;            /* for messages */
{
  int r;
  uInt hn = 0;          /* hufts used in space */
  uIntf *v;             /* work area for huft_build */

  /* allocate work area */
  if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
    return Z_MEM_ERROR;

  /* build literal/length tree */
  r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
  if (r != Z_OK || *bl == 0)
  {
    if (r == Z_DATA_ERROR)
      z->msg = (char*)"oversubscribed literal/length tree";
    else if (r != Z_MEM_ERROR)
    {
      z->msg = (char*)"incomplete literal/length tree";
      r = Z_DATA_ERROR;
    }
    ZFREE(z, v);
    return r;
  }

  /* build distance tree */
  r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
  if (r != Z_OK || (*bd == 0 && nl > 257))
  {
    if (r == Z_DATA_ERROR)
      z->msg = (char*)"oversubscribed distance tree";
    else if (r == Z_BUF_ERROR) {
#ifdef PKZIP_BUG_WORKAROUND
      r = Z_OK;
    }
#else
      z->msg = (char*)"incomplete distance tree";
      r = Z_DATA_ERROR;
    }
    else if (r != Z_MEM_ERROR)
    {
      z->msg = (char*)"empty distance tree with lengths";
      r = Z_DATA_ERROR;
    }
    ZFREE(z, v);
    return r;
#endif
  }

  /* done */
  ZFREE(z, v);
  return Z_OK;
}


/* build fixed tables only once--keep them here */
#ifdef BUILDFIXED
local int fixed_built = 0;
#define FIXEDH 544      /* number of hufts used by fixed tables */
local inflate_huft fixed_mem[FIXEDH];
local uInt fixed_bl;
local uInt fixed_bd;
local inflate_huft *fixed_tl;
local inflate_huft *fixed_td;
#else
#include "inffixed.h"
#endif


int inflate_trees_fixed(bl, bd, tl, td, z)
uIntf *bl;               /* literal desired/actual bit depth */
uIntf *bd;               /* distance desired/actual bit depth */
inflate_huft * FAR *tl;  /* literal/length tree result */
inflate_huft * FAR *td;  /* distance tree result */
z_streamp z;             /* for memory allocation */
{
#ifdef BUILDFIXED
  /* build fixed tables if not already */
  if (!fixed_built)
  {
    int k;              /* temporary variable */
    uInt f = 0;         /* number of hufts used in fixed_mem */
    uIntf *c;           /* length list for huft_build */
    uIntf *v;           /* work area for huft_build */

    /* allocate memory */
    if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
      return Z_MEM_ERROR;
    if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
    {
      ZFREE(z, c);
      return Z_MEM_ERROR;
    }

    /* literal table */
    for (k = 0; k < 144; k++)
      c[k] = 8;
    for (; k < 256; k++)
      c[k] = 9;
    for (; k < 280; k++)
      c[k] = 7;
    for (; k < 288; k++)
      c[k] = 8;
    fixed_bl = 9;
    huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl,
               fixed_mem, &f, v);

    /* distance table */
    for (k = 0; k < 30; k++)
      c[k] = 5;
    fixed_bd = 5;
    huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd,
               fixed_mem, &f, v);

    /* done */
    ZFREE(z, v);
    ZFREE(z, c);
    fixed_built = 1;
  }
#endif
  *bl = fixed_bl;
  *bd = fixed_bd;
  *tl = fixed_tl;
  *td = fixed_td;
  return Z_OK;
}
1	/* inftrees.c -- generate Huffman trees for efficient decoding
2	* Copyright (C) 1995-2002 Mark Adler
3	* For conditions of distribution and use, see copyright notice in zlib.h
4	*/
5
6	#include "zutil.h"
7	#include "inftrees.h"
8
9	#if !defined(BUILDFIXED) && !defined(STDC)
10	# define BUILDFIXED /* non ANSI compilers may not accept inffixed.h */
11	#endif
12
13	const char inflate_copyright[] =
14	" inflate 1.1.4 Copyright 1995-2002 Mark Adler ";
15	/*
16	If you use the zlib library in a product, an acknowledgment is welcome
17	in the documentation of your product. If for some reason you cannot
18	include such an acknowledgment, I would appreciate that you keep this
19	copyright string in the executable of your product.
20	*/
21	struct internal_state {int dummy;}; /* for buggy compilers */
22
23	/* simplify the use of the inflate_huft type with some defines */
24	#define exop word.what.Exop
25	#define bits word.what.Bits
26
27
28	local int huft_build OF((
29	uIntf , / code lengths in bits */
30	uInt, /* number of codes */
31	uInt, /* number of "simple" codes */
32	const uIntf , / list of base values for non-simple codes */
33	const uIntf , / list of extra bits for non-simple codes */
34	inflate_huft * FAR,/ result: starting table */
35	uIntf , / maximum lookup bits (returns actual) */
36	inflate_huft , / space for trees */
37	uInt , / hufts used in space */
38	uIntf * )); /* space for values */
39
40	/* Tables for deflate from PKZIP's appnote.txt. */
41	local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
42	3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
43	35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
44	/* see note #13 above about 258 */
45	local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
46	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
47	3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */
48	local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
49	1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
50	257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
51	8193, 12289, 16385, 24577};
52	local const uInt cpdext[30] = { /* Extra bits for distance codes */
53	0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
54	7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
55	12, 12, 13, 13};
56
57	/*
58	Huffman code decoding is performed using a multi-level table lookup.
59	The fastest way to decode is to simply build a lookup table whose
60	size is determined by the longest code. However, the time it takes
61	to build this table can also be a factor if the data being decoded
62	is not very long. The most common codes are necessarily the
63	shortest codes, so those codes dominate the decoding time, and hence
64	the speed. The idea is you can have a shorter table that decodes the
65	shorter, more probable codes, and then point to subsidiary tables for
66	the longer codes. The time it costs to decode the longer codes is
67	then traded against the time it takes to make longer tables.
68
69	This results of this trade are in the variables lbits and dbits
70	below. lbits is the number of bits the first level table for literal/
71	length codes can decode in one step, and dbits is the same thing for
72	the distance codes. Subsequent tables are also less than or equal to
73	those sizes. These values may be adjusted either when all of the
74	codes are shorter than that, in which case the longest code length in
75	bits is used, or when the shortest code is longer than the requested
76	table size, in which case the length of the shortest code in bits is
77	used.
78
79	There are two different values for the two tables, since they code a
80	different number of possibilities each. The literal/length table
81	codes 286 possible values, or in a flat code, a little over eight
82	bits. The distance table codes 30 possible values, or a little less
83	than five bits, flat. The optimum values for speed end up being
84	about one bit more than those, so lbits is 8+1 and dbits is 5+1.
85	The optimum values may differ though from machine to machine, and
86	possibly even between compilers. Your mileage may vary.
87	*/
88
89
90	/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
91	#define BMAX 15 /* maximum bit length of any code */
92
93	local int huft_build(b, n, s, d, e, t, m, hp, hn, v)
94	uIntf b; / code lengths in bits (all assumed <= BMAX) */
95	uInt n; /* number of codes (assumed <= 288) */
96	uInt s; /* number of simple-valued codes (0..s-1) */
97	const uIntf d; / list of base values for non-simple codes */
98	const uIntf e; / list of extra bits for non-simple codes */
99	inflate_huft * FAR t; / result: starting table */
100	uIntf m; / maximum lookup bits, returns actual */
101	inflate_huft hp; / space for trees */
102	uInt hn; / hufts used in space */
103	uIntf v; / working area: values in order of bit length */
104	/* Given a list of code lengths and a maximum table size, make a set of
105	tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR
106	if the given code set is incomplete (the tables are still built in this
107	case), or Z_DATA_ERROR if the input is invalid. */
108	{
109
110	uInt a; /* counter for codes of length k */
111	uInt c[BMAX+1]; /* bit length count table */
112	uInt f; /* i repeats in table every f entries */
113	int g; /* maximum code length */
114	int h; /* table level */
115	register uInt i; /* counter, current code */
116	register uInt j; /* counter */
117	register int k; /* number of bits in current code */
118	int l; /* bits per table (returned in m) */
119	uInt mask; /* (1 << w) - 1, to avoid cc -O bug on HP */
120	register uIntf p; / pointer into c[], b[], or v[] */
121	inflate_huft q; / points to current table */
122	struct inflate_huft_s r; /* table entry for structure assignment */
123	inflate_huft u[BMAX]; / table stack */
124	register int w; /* bits before this table == (l * h) */
125	uInt x[BMAX+1]; /* bit offsets, then code stack */
126	uIntf xp; / pointer into x */
127	int y; /* number of dummy codes added */
128	uInt z; /* number of entries in current table */
129
130
131	/* Generate counts for each bit length */
132	p = c;
133	#define C0 *p++ = 0;
134	#define C2 C0 C0 C0 C0
135	#define C4 C2 C2 C2 C2
136	C4 /* clear c[]--assume BMAX+1 is 16 */
137	p = b; i = n;
138	do {
139	c[p++]++; / assume all entries <= BMAX */
140	} while (--i);
141	if (c[0] == n) /* null input--all zero length codes */
142	{
143	t = (inflate_huft )Z_NULL;
144	*m = 0;
145	return Z_OK;
146	}
147
148
149	/* Find minimum and maximum length, bound m by those /
150	l = *m;
151	for (j = 1; j <= BMAX; j++)
152	if (c[j])
153	break;
154	k = j; /* minimum code length */
155	if ((uInt)l < j)
156	l = j;
157	for (i = BMAX; i; i--)
158	if (c[i])
159	break;
160	g = i; /* maximum code length */
161	if ((uInt)l > i)
162	l = i;
163	*m = l;
164
165
166	/* Adjust last length count to fill out codes, if needed */
167	for (y = 1 << j; j < i; j++, y <<= 1)
168	if ((y -= c[j]) < 0)
169	return Z_DATA_ERROR;
170	if ((y -= c[i]) < 0)
171	return Z_DATA_ERROR;
172	c[i] += y;
173
174
175	/* Generate starting offsets into the value table for each length */
176	x[1] = j = 0;
177	p = c + 1; xp = x + 2;
178	while (--i) { /* note that i == g from above */
179	xp++ = (j += p++);
180	}
181
182
183	/* Make a table of values in order of bit lengths */
184	p = b; i = 0;
185	do {
186	if ((j = *p++) != 0)
187	v[x[j]++] = i;
188	} while (++i < n);
189	n = x[g]; /* set n to length of v */
190
191
192	/* Generate the Huffman codes and for each, make the table entries */
193	x[0] = i = 0; /* first Huffman code is zero */
194	p = v; /* grab values in bit order */
195	h = -1; /* no tables yet--level -1 */
196	w = -l; /* bits decoded == (l * h) */
197	u[0] = (inflate_huft )Z_NULL; / just to keep compilers happy */
198	q = (inflate_huft )Z_NULL; / ditto */
199	z = 0; /* ditto */
200
201	/* go through the bit lengths (k already is bits in shortest code) */
202	for (; k <= g; k++)
203	{
204	a = c[k];
205	while (a--)
206	{
207	/* here i is the Huffman code of length k bits for value p /
208	/* make tables up to required level */
209	while (k > w + l)
210	{
211	h++;
212	w += l; /* previous table always l bits */
213
214	/* compute minimum size table less than or equal to l bits */
215	z = g - w;
216	z = z > (uInt)l ? l : z; /* table size upper limit */
217	if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */
218	{ /* too few codes for k-w bit table */
219	f -= a + 1; /* deduct codes from patterns left */
220	xp = c + k;
221	if (j < z)
222	while (++j < z) /* try smaller tables up to z bits */
223	{
224	if ((f <<= 1) <= *++xp)
225	break; /* enough codes to use up j bits */
226	f -= xp; / else deduct codes from patterns */
227	}
228	}
229	z = 1 << j; /* table entries for j-bit table */
230
231	/* allocate new table */
232	if (hn + z > MANY) / (note: doesn't matter for fixed) */
233	return Z_DATA_ERROR; /* overflow of MANY */
234	u[h] = q = hp + *hn;
235	*hn += z;
236
237	/* connect to last table, if there is one */
238	if (h)
239	{
240	x[h] = i; /* save pattern for backing up */
241	r.bits = (Byte)l; /* bits to dump before this table */
242	r.exop = (Byte)j; /* bits in this table */
243	j = i >> (w - l);
244	r.base = (uInt)(q - u[h-1] - j); /* offset to this table */
245	u[h-1][j] = r; /* connect to last table */
246	}
247	else
248	t = q; / first table is returned result */
249	}
250
251	/* set up table entry in r */
252	r.bits = (Byte)(k - w);
253	if (p >= v + n)
254	r.exop = 128 + 64; /* out of values--invalid code */
255	else if (*p < s)
256	{
257	r.exop = (Byte)(p < 256 ? 0 : 32 + 64); / 256 is end-of-block */
258	r.base = p++; / simple code is just the value */
259	}
260	else
261	{
262	r.exop = (Byte)(e[p - s] + 16 + 64);/ non-simple--look up in lists */
263	r.base = d[*p++ - s];
264	}
265
266	/* fill code-like entries with r */
267	f = 1 << (k - w);
268	for (j = i >> w; j < z; j += f)
269	q[j] = r;
270
271	/* backwards increment the k-bit code i */
272	for (j = 1 << (k - 1); i & j; j >>= 1)
273	i ^= j;
274	i ^= j;
275
276	/* backup over finished tables */
277	mask = (1 << w) - 1; /* needed on HP, cc -O bug */
278	while ((i & mask) != x[h])
279	{
280	h--; /* don't need to update q */
281	w -= l;
282	mask = (1 << w) - 1;
283	}
284	}
285	}
286
287
288	/* Return Z_BUF_ERROR if we were given an incomplete table */
289	return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
290	}
291
292
293	int inflate_trees_bits(c, bb, tb, hp, z)
294	uIntf c; / 19 code lengths */
295	uIntf bb; / bits tree desired/actual depth */
296	inflate_huft * FAR tb; / bits tree result */
297	inflate_huft hp; / space for trees */
298	z_streamp z; /* for messages */
299	{
300	int r;
301	uInt hn = 0; /* hufts used in space */
302	uIntf v; / work area for huft_build */
303
304	if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL)
305	return Z_MEM_ERROR;
306	r = huft_build(c, 19, 19, (uIntf)Z_NULL, (uIntf)Z_NULL,
307	tb, bb, hp, &hn, v);
308	if (r == Z_DATA_ERROR)
309	z->msg = (char*)"oversubscribed dynamic bit lengths tree";
310	else if (r == Z_BUF_ERROR \|\| *bb == 0)
311	{
312	z->msg = (char*)"incomplete dynamic bit lengths tree";
313	r = Z_DATA_ERROR;
314	}
315	ZFREE(z, v);
316	return r;
317	}
318
319
320	int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z)
321	uInt nl; /* number of literal/length codes */
322	uInt nd; /* number of distance codes */
323	uIntf c; / that many (total) code lengths */
324	uIntf bl; / literal desired/actual bit depth */
325	uIntf bd; / distance desired/actual bit depth */
326	inflate_huft * FAR tl; / literal/length tree result */
327	inflate_huft * FAR td; / distance tree result */
328	inflate_huft hp; / space for trees */
329	z_streamp z; /* for messages */
330	{
331	int r;
332	uInt hn = 0; /* hufts used in space */
333	uIntf v; / work area for huft_build */
334
335	/* allocate work area */
336	if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
337	return Z_MEM_ERROR;
338
339	/* build literal/length tree */
340	r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
341	if (r != Z_OK \|\| *bl == 0)
342	{
343	if (r == Z_DATA_ERROR)
344	z->msg = (char*)"oversubscribed literal/length tree";
345	else if (r != Z_MEM_ERROR)
346	{
347	z->msg = (char*)"incomplete literal/length tree";
348	r = Z_DATA_ERROR;
349	}
350	ZFREE(z, v);
351	return r;
352	}
353
354	/* build distance tree */
355	r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
356	if (r != Z_OK \|\| (*bd == 0 && nl > 257))
357	{
358	if (r == Z_DATA_ERROR)
359	z->msg = (char*)"oversubscribed distance tree";
360	else if (r == Z_BUF_ERROR) {
361	#ifdef PKZIP_BUG_WORKAROUND
362	r = Z_OK;
363	}
364	#else
365	z->msg = (char*)"incomplete distance tree";
366	r = Z_DATA_ERROR;
367	}
368	else if (r != Z_MEM_ERROR)
369	{
370	z->msg = (char*)"empty distance tree with lengths";
371	r = Z_DATA_ERROR;
372	}
373	ZFREE(z, v);
374	return r;
375	#endif
376	}
377
378	/* done */
379	ZFREE(z, v);
380	return Z_OK;
381	}
382
383
384	/* build fixed tables only once--keep them here */
385	#ifdef BUILDFIXED
386	local int fixed_built = 0;
387	#define FIXEDH 544 /* number of hufts used by fixed tables */
388	local inflate_huft fixed_mem[FIXEDH];
389	local uInt fixed_bl;
390	local uInt fixed_bd;
391	local inflate_huft *fixed_tl;
392	local inflate_huft *fixed_td;
393	#else
394	#include "inffixed.h"
395	#endif
396
397
398	int inflate_trees_fixed(bl, bd, tl, td, z)
399	uIntf bl; / literal desired/actual bit depth */
400	uIntf bd; / distance desired/actual bit depth */
401	inflate_huft * FAR tl; / literal/length tree result */
402	inflate_huft * FAR td; / distance tree result */
403	z_streamp z; /* for memory allocation */
404	{
405	#ifdef BUILDFIXED
406	/* build fixed tables if not already */
407	if (!fixed_built)
408	{
409	int k; /* temporary variable */
410	uInt f = 0; /* number of hufts used in fixed_mem */
411	uIntf c; / length list for huft_build */
412	uIntf v; / work area for huft_build */
413
414	/* allocate memory */
415	if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
416	return Z_MEM_ERROR;
417	if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL)
418	{
419	ZFREE(z, c);
420	return Z_MEM_ERROR;
421	}
422
423	/* literal table */
424	for (k = 0; k < 144; k++)
425	c[k] = 8;
426	for (; k < 256; k++)
427	c[k] = 9;
428	for (; k < 280; k++)
429	c[k] = 7;
430	for (; k < 288; k++)
431	c[k] = 8;
432	fixed_bl = 9;
433	huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl,
434	fixed_mem, &f, v);
435
436	/* distance table */
437	for (k = 0; k < 30; k++)
438	c[k] = 5;
439	fixed_bd = 5;
440	huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd,
441	fixed_mem, &f, v);
442
443	/* done */
444	ZFREE(z, v);
445	ZFREE(z, c);
446	fixed_built = 1;
447	}
448	#endif
449	*bl = fixed_bl;
450	*bd = fixed_bd;
451	*tl = fixed_tl;
452	*td = fixed_td;
453	return Z_OK;
454	}