Lines Matching defs:table
258 uInt hash_size; /* number of elements in hash table */
298 /* Insert new strings in the hash table only if the match length is not
351 * a highly compressible string table.) Smaller buffer sizes give
571 * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
1144 /* Slide the hash table (could be avoided with 32 bit values
1278 /* Insert new strings in the hash table only if the match length
1283 s->match_length--; /* string at strstart already in hash table */
1382 /* Do not insert strings in hash table beyond this. */
1389 /* Insert in hash table all strings up to the end of the match.
1392 * the hash table.
2518 * method would use a table)
2649 /* Huffman code lookup table entry--this entry is four bytes for machines
2665 inflate_huft *Next; /* pointer to next level of table */
3055 TABLE, /* get table lengths */
3068 uInt table; /* table lengths (14 bits) */
3168 3. There is an implied maximum of 7 bits for the bit length table and
3357 s->sub.trees.table = t = (uInt)b & 0x3fff;
3378 Tracev((stderr, "inflate: table sizes ok\n"));
3381 while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
3403 while (t = s->sub.trees.table,
3428 t = s->sub.trees.table;
3453 t = s->sub.trees.table;
3619 inflate_huft * FAR*,/* result: starting table */
3651 Huffman code decoding is performed using a multi-level table lookup.
3652 The fastest way to decode is to simply build a lookup table whose
3654 to build this table can also be a factor if the data being decoded
3657 the speed. The idea is you can have a shorter table that decodes the
3663 below. lbits is the number of bits the first level table for literal/
3669 table size, in which case the length of the shortest code in bits is
3673 different number of possibilities each. The literal/length table
3675 bits. The distance table codes 30 possible values, or a little less
3697 inflate_huft * FAR *t; /* result: starting table */
3700 /* Given a list of code lengths and a maximum table size, make a set of
3708 uInt c[BMAX+1]; /* bit length count table */
3709 uInt f; /* i repeats in table every f entries */
3711 int h; /* table level */
3715 int l; /* bits per table (returned in m) */
3717 inflate_huft *q; /* points to current table */
3718 struct inflate_huft_s r; /* table entry for structure assignment */
3719 inflate_huft *u[BMAX]; /* table stack */
3721 register int w; /* bits before this table == (l * h) */
3725 uInt z; /* number of entries in current table */
3772 /* Generate starting offsets into the value table for each length */
3780 /* Make a table of values in order of bit lengths */
3788 /* Generate the Huffman codes and for each, make the table entries */
3808 w += l; /* previous table always l bits */
3810 /* compute minimum size table less than or equal to l bits */
3811 z = (z = g - w) > (uInt)l ? l : z; /* table size upper limit */
3812 if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */
3813 { /* too few codes for k-w bit table */
3824 z = 1 << j; /* table entries for j-bit table */
3826 /* allocate and link in new table */
3840 u[h] = ++q; /* table starts after link */
3842 /* connect to last table, if there is one */
3846 r.bits = (Byte)l; /* bits to dump before this table */
3847 r.exop = (Byte)j; /* bits in this table */
3848 r.next = q; /* pointer to this table */
3850 u[h-1][j] = r; /* connect to last table */
3854 /* set up table entry in r */
3889 /* Return Z_BUF_ERROR if we were given an incomplete table */
4020 /* literal table */
4032 /* distance table */
4051 inflate_huft *t; /* table to free */
4055 each table. */
4205 if ((e & 64) == 0) /* next table */
4243 if ((e & 64) == 0) /* next table */