Lines Matching defs:LEN
239 # define zmemzero(dest, len) _fmemset(dest, 0, len)
243 # define zmemzero(dest, len) memset(dest, 0, len)
246 extern void zmemcpy(Bytef* dest, const Bytef* source, uInt len);
247 extern int zmemcmp(const Bytef* s1, const Bytef* s2, uInt len);
248 extern void zmemzero(Bytef* dest, uInt len);
273 uInt len);
343 ush len; /* length of bit string */
350 #define Len dl.len
590 { uch len = (length); \
593 s->l_buf[s->last_lit++] = len; \
595 s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
1027 unsigned len = s->pending;
1029 if (len > strm->avail_out) len = strm->avail_out;
1030 if (len == 0) return;
1033 zmemcpy(strm->next_out, s->pending_out, len);
1034 strm->next_out += len;
1036 s->pending_out += len;
1037 strm->total_out += len;
1038 strm->avail_out -= len;
1039 s->pending -= len;
1292 unsigned len = strm->avail_in;
1294 if (len > size) len = size;
1295 if (len == 0) return 0;
1297 strm->avail_in -= len;
1300 strm->adler = adler32(strm->adler, strm->next_in, len);
1302 zmemcpy(buf, strm->next_in, len);
1303 strm->next_in += len;
1304 strm->total_in += len;
1306 return (int)len;
1356 int len; /* length of current match */
1433 len = (MAX_MATCH - 1) - (int)(strend-scan);
1464 len = MAX_MATCH - (int)(strend - scan);
1469 if (len > best_len) {
1471 best_len = len;
1472 if (len >= nice_match) break;
1497 register int len; /* length of current match */
1536 len = MAX_MATCH - (int)(strend - scan);
1538 if (len < MIN_MATCH) return MIN_MATCH - 1;
1541 return len <= s->lookahead ? len : s->lookahead;
2259 local void copy_block(deflate_state *s, charf *buf, unsigned len,
2267 # define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
2273 send_bits(s, tree[c].Code, tree[c].Len); }
2318 { int len = length;\
2319 if (s->bi_valid > (int)Buf_size - len) {\
2324 s->bi_valid += len - Buf_size;\
2327 s->bi_valid += len;\
2393 while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
2394 while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
2395 while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
2396 while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
2405 static_dtree[n].Len = 5;
2440 static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
2446 static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
2580 * OUT assertions: the field len is set to the optimal bit length, the
2606 tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
2610 bits = tree[tree[n].Dad].Len + 1;
2612 tree[n].Len = (ush)bits;
2622 if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
2652 if (tree[m].Len != (unsigned) bits) {
2653 Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
2654 s->opt_len += ((long)bits - (long)tree[m].Len)
2656 tree[m].Len = (ush)bits;
2667 * the given tree and the field len is set for all tree elements.
2694 int len = tree[n].Len;
2695 if (len == 0) continue;
2697 tree[n].Code = bi_reverse(next_code[len]++, len);
2700 n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
2708 * OUT assertions: the fields len and code are set to the optimal bit length
2733 tree[n].Len = 0;
2746 s->opt_len--; if (stree) s->static_len -= stree[node].Len;
2790 /* The field len is now set, we can generate the bit codes */
2805 int nextlen = tree[0].Len; /* length of next code */
2811 tree[max_code+1].Len = (ush)0xffff; /* guard */
2814 curlen = nextlen; nextlen = tree[n+1].Len;
2849 int nextlen = tree[0].Len; /* length of next code */
2854 /* tree[max_code+1].Len = -1; */ /* guard already set */
2858 curlen = nextlen; nextlen = tree[n+1].Len;
2911 if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
2940 send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
3210 s->last_eob_len = ltree[END_BLOCK].Len;
3231 * Reverse the first len bits of a code, using straightforward code (a faster
3233 * IN assertion: 1 <= len <= 15
3236 int len) /* its bit length */
3242 } while (--len > 0);
3285 unsigned len, /* its length */
3292 put_short(s, (ush)len);
3293 put_short(s, (ush)~len);
3299 s->bits_sent += (ulg)len<<3;
3302 zmemcpy(&s->pending_buf[s->pending], buf, len);
3303 s->pending += len;
5074 START, /* x: set up for LEN */
5075 LEN, /* i: get length/literal/eob next */
5093 uInt len;
5098 } code; /* if LEN or DIST, where in tree */
5154 case START: /* x: set up for LEN */
5170 c->mode = LEN;
5172 case LEN: /* i: get length/literal/eob next */
5190 c->len = t->base;
5213 c->len += (uInt)b & inflate_mask[j];
5217 Tracevv((stderr, "inflate: length %u\n", c->len));
5255 while (c->len)
5261 c->len--;
5660 void zmemcpy(dest, source, len)
5663 uInt len;
5665 if (len == 0) return;
5668 } while (--len != 0);
5671 int zmemcmp(s1, s2, len)
5674 uInt len;
5678 for (j = 0; j < len; j++) {
5684 void zmemzero(dest, len)
5686 len;
5688 if (len == 0) return;
5691 } while (--len != 0);
5848 uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len)
5856 while (len > 0) {
5857 k = len < NMAX ? len : NMAX;
5858 len -= k;
Indexes created Tue Sep 30 17:09:57 GMT 2025