Lines Matching +refs:val +refs:length
1200 /* do length NMAX blocks -- requires just one modulo operation */
1241 /* number of length codes, not counting the special END_BLOCK code */
1279 ush len; /* length of bit string */
1328 * performed with a length multiple of the block size. Also, it limits
1363 uInt match_length; /* length of best match */
1377 * length. A higher limit improves compression ratio but degrades the
1387 /* Insert new strings in the hash table only if the match length is not
1388 * greater than this length. This saves time but degrades compression.
1402 struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
1408 struct tree_desc_s bl_desc; /* desc. for bit length tree */
1411 /* number of codes at each bit length for an optimal tree */
1454 ulg opt_len; /* bit length of current block with optimal trees */
1455 ulg static_len; /* bit length of current block with static trees */
1457 int last_eob_len; /* bit length of EOB code for last block */
1460 ulg compressed_len; /* total bit length of compressed file mod 2^32 */
1461 ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
1525 # define _tr_tally_dist(s, distance, length, flush) \
1526 { uch len = (length); \
1537 # define _tr_tally_dist(s, distance, length, flush) \
1538 flush = _tr_tally(s, distance, length)
1549 unsigned short val; /* offset in table or code value */
1555 0001eeee - length or distance, eeee is the number of extra bits
1561 exhaustive search was 1444 code structures (852 for length/literals
1586 EXLEN, /* i: waiting for extra length (gzip) */
1595 STORED, /* i: waiting for stored size (length and complement) */
1598 LENLENS, /* i: waiting for code length code lengths */
1599 CODELENS, /* i: waiting for length/lit and distance code lengths */
1600 LEN, /* i: waiting for length/lit code */
1601 LENEXT, /* i: waiting for length extra bits */
1607 LENGTH, /* i: waiting for 32-bit length (gzip) */
1658 unsigned length; /* literal or length of data to copy */
1663 code const FAR *lencode; /* starting table for length/literal codes */
1668 unsigned ncode; /* number of code length code lengths */
1669 unsigned nlen; /* number of length code lengths */
1713 unsigned len; /* a code's length in bits */
1731 unsigned short count[MAXBITS+1]; /* number of codes of each length */
1732 unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
1750 code lengths are lens[0..codes-1]. Each length corresponds to the
1752 symbols by length from short to long, and retaining the symbol order
1754 for the first code of the shortest length, and the codes are integer
1755 increments for the same length, and zeros are appended as the length
1763 1..MAXBITS is interpreted as that code length. zero means that that
1766 The codes are sorted by computing a count of codes for each length,
1767 creating from that a table of starting indices for each length in the
1772 The length counts are used for other purposes as well, i.e. finding
1773 the minimum and maximum length codes, determining if there are any
1775 at length counts to determine sub-table sizes when building the
1793 this.val = (unsigned short)0;
1813 /* generate offsets into symbol table for each length for sorting */
1818 /* sort symbols by length, by symbol order within each length */
1825 with length len. That code is converted to an index by dropping drop
1837 code lengths to determine what size sub-table is needed. The length
1849 all codes of length max, i.e. all codes, have been processed. This
1876 len = min; /* starting code length */
1894 this.val = work[sym];
1898 this.val = base[work[sym]];
1902 this.val = 0;
1941 /* determine length of next table */
1960 (*table)[low].val = (unsigned short)(next - *table);
1973 this.val = (unsigned short)0;
2030 Decode literal, length, and distance codes and write out the resulting
2053 - The maximum input bits used by a length/distance pair is 15 bits for the
2054 length code, 5 bits for the length extra, 15 bits for the distance code,
2059 - The maximum bytes that a single length/distance pair can output is 258
2060 bytes, which is the maximum length that can be coded. inflate_fast()
2085 unsigned lmask; /* mask for first level of length codes */
2090 unsigned len; /* match length, unused bytes */
2115 /* decode literals and length/distances until end-of-block or not enough
2131 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
2133 "inflate: literal 0x%02x\n", this.val));
2134 PUP(out) = (unsigned char)(this.val);
2136 else if (op & 16) { /* length base */
2137 len = (unsigned)(this.val);
2148 Tracevv((stderr, "inflate: length %u\n", len));
2162 dist = (unsigned)(this.val);
2245 do { /* minimum length is three */
2259 this = dcode[this.val + (hold & ((((unsigned int)1) << op) - 1))];
2268 else if ((op & 64) == 0) { /* 2nd level length code */
2269 this = lcode[this.val + (hold & ((((unsigned int)1) << op) - 1))];
2278 strm->msg = (char *)"invalid literal/length code";
2309 - Swapping literal/length else
2422 Return state with length and distance decoding tables and index sizes set to
2727 if there is no input available. The decoding of variable length codes uses
2788 unsigned len; /* length to copy for repeats, bits to drop */
2890 state->length = (unsigned)(hold);
2901 copy = state->length;
2906 len = state->head->extra_len - state->length;
2915 state->length -= copy;
2917 if (state->length) goto inf_leave;
2919 state->length = 0;
2929 state->length < state->head->name_max)
2930 state->head->name[state->length++] = len;
2940 state->length = 0;
2950 state->length < state->head->comm_max)
2951 state->head->comment[state->length++] = len;
3034 state->length = (unsigned)hold & 0xffff;
3035 Tracev((stderr, "inflate: stored length %u\n",
3036 state->length));
3040 copy = state->length;
3050 state->length -= copy;
3066 strm->msg = (char *)"too many length or distance symbols";
3102 if (this.val < 16) {
3105 state->lens[state->have++] = this.val;
3108 if (this.val == 16) {
3112 strm->msg = (char *)"invalid bit length repeat";
3120 else if (this.val == 17) {
3135 strm->msg = (char *)"invalid bit length repeat";
3184 this = state->lencode[last.val +
3192 state->length = (unsigned)this.val;
3194 Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
3196 "inflate: literal 0x%02x\n", this.val));
3206 strm->msg = (char *)"invalid literal/length code";
3215 state->length += BITS(state->extra);
3218 Tracevv((stderr, "inflate: length %u\n", state->length));
3229 this = state->distcode[last.val +
3242 state->offset = (unsigned)this.val;
3276 if (copy > state->length) copy = state->length;
3280 copy = state->length;
3284 state->length -= copy;
3288 if (state->length == 0) state->mode = LEN;
3292 *put++ = (unsigned char)(state->length);
3324 strm->msg = (char *)"incorrect length check";
3329 Tracev((stderr, "inflate: length matches trailer\n"));
3530 Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
3532 inflate is waiting for these length bytes.
4070 /* The uncompressed length returned by above getlong() may be