Lines Matching refs:zs
163 #define htabof(i) zs->zs_htab[i]
164 #define codetabof(i) zs->zs_codetab[i]
167 #define tab_suffixof(i) ((u_char *)(zs->zs_htab))[i]
215 struct s_zstate *zs;
220 zs = cookie;
223 switch (zs->zs_state) {
229 zs->zs_state = S_MIDDLE;
231 zs->zs_maxmaxcode = 1L << zs->zs_maxbits;
232 if (write(zs->zs_fd, z_magic, sizeof(z_magic)) !=
235 tmp = (u_char)(zs->zs_maxbits | zs->zs_block_compress);
236 if (write(zs->zs_fd, &tmp, sizeof(tmp)) != sizeof(tmp))
239 zs->zs_bp = zs->zs_buf;
240 zs->zs_offset = 0;
241 zs->zs_bytes_out = 3; /* Includes 3-byte header mojo. */
242 zs->zs_out_count = 0;
243 zs->zs_clear_flg = 0;
244 zs->zs_ratio = 0;
245 zs->zs_in_count = 1;
246 zs->zs_checkpoint = CHECK_GAP;
247 zs->zs_maxcode = MAXCODE(zs->zs_n_bits = INIT_BITS);
248 zs->zs_free_ent = ((zs->zs_block_compress) ? FIRST : 256);
250 zs->zs_ent = *bp++;
253 zs->zs_hshift = 0;
254 for (zs->zs_fcode = (long)zs->zs_hsize; zs->zs_fcode < 65536L;
255 zs->zs_fcode *= 2L)
256 zs->zs_hshift++;
258 zs->zs_hshift = 8 - zs->zs_hshift;
260 zs->zs_hsize_reg = zs->zs_hsize;
262 cl_hash(zs, (count_int)zs->zs_hsize_reg);
267 zs->zs_in_count++;
268 zs->zs_fcode = (long)(((long)c << zs->zs_maxbits) +
269 zs->zs_ent);
271 i = ((c << zs->zs_hshift) ^ zs->zs_ent);
273 if (htabof(i) == zs->zs_fcode) {
274 zs->zs_ent = codetabof(i);
279 disp = zs->zs_hsize_reg - i;
283 i += zs->zs_hsize_reg;
285 if (htabof(i) == zs->zs_fcode) {
286 zs->zs_ent = codetabof(i);
291 nomatch: if (output(zs, (code_int) zs->zs_ent) == -1)
293 zs->zs_out_count++;
294 zs->zs_ent = c;
295 if (zs->zs_free_ent < zs->zs_maxmaxcode) {
297 codetabof(i) = zs->zs_free_ent++;
298 htabof(i) = zs->zs_fcode;
299 } else if ((count_int)zs->zs_in_count >=
300 zs->zs_checkpoint && zs->zs_block_compress) {
301 if (cl_block(zs) == -1)
312 struct s_zstate *zs;
315 zs = cookie;
316 if (zs->zs_mode == 'w') { /* Put out the final code. */
317 if (output(zs, (code_int) zs->zs_ent) == -1) {
318 (void)close(zs->zs_fd);
319 free(zs);
322 zs->zs_out_count++;
323 if (output(zs, (code_int) - 1) == -1) {
324 (void)close(zs->zs_fd);
325 free(zs);
334 info->total_in = (off_t)zs->zs_in_count;
335 info->total_out = (off_t)zs->zs_bytes_out;
339 setfile(name, zs->zs_fd, sb);
341 rval = close(zs->zs_fd);
342 free(zs);
367 output(struct s_zstate *zs, code_int ocode)
376 bp = zs->zs_bp + (zs->zs_offset >> 3);
377 r_off = zs->zs_offset & 7;
378 bits = zs->zs_n_bits;
397 zs->zs_offset += zs->zs_n_bits;
398 if (zs->zs_offset == (zs->zs_n_bits << 3)) {
399 zs->zs_bp += zs->zs_n_bits;
400 zs->zs_offset = 0;
406 if (zs->zs_free_ent > zs->zs_maxcode ||
407 (zs->zs_clear_flg > 0)) {
412 if (zs->zs_offset > 0) {
413 zs->zs_bp += zs->zs_n_bits;
414 zs->zs_offset = 0;
417 if (zs->zs_clear_flg) {
418 zs->zs_maxcode =
419 MAXCODE(zs->zs_n_bits = INIT_BITS);
420 zs->zs_clear_flg = 0;
422 zs->zs_n_bits++;
423 if (zs->zs_n_bits == zs->zs_maxbits)
424 zs->zs_maxcode = zs->zs_maxmaxcode;
426 zs->zs_maxcode =
427 MAXCODE(zs->zs_n_bits);
431 if (zs->zs_bp + zs->zs_n_bits > &zs->zs_buf[ZBUFSIZ]) {
432 bits = zs->zs_bp - zs->zs_buf;
433 if (write(zs->zs_fd, zs->zs_buf, bits) != bits)
435 zs->zs_bytes_out += bits;
436 if (zs->zs_offset > 0)
438 zs->zs_bp = zs->zs_buf;
442 if (zs->zs_offset > 0)
443 zs->zs_bp += (zs->zs_offset + 7) / 8;
444 if (zs->zs_bp > zs->zs_buf) {
445 bits = zs->zs_bp - zs->zs_buf;
446 if (write(zs->zs_fd, zs->zs_buf, bits) != bits)
448 zs->zs_bytes_out += bits;
450 zs->zs_offset = 0;
451 zs->zs_bp = zs->zs_buf;
466 struct s_zstate *zs;
472 zs = cookie;
475 switch (zs->zs_state) {
477 zs->zs_state = S_MIDDLE;
478 zs->zs_bp = zs->zs_buf;
480 read(zs->zs_fd, header, sizeof(header));
483 zs->zs_state = S_MIDDLE;
484 zs->zs_bp = zs->zs_buf;
488 read(zs->zs_fd, &header[2], 1);
501 zs->zs_maxbits = header[2]; /* Set -b from file. */
502 zs->zs_in_count += sizeof(header);
503 zs->zs_block_compress = zs->zs_maxbits & BLOCK_MASK;
504 zs->zs_maxbits &= BIT_MASK;
505 zs->zs_maxmaxcode = 1L << zs->zs_maxbits;
506 if (zs->zs_maxbits > BITS) {
511 zs->zs_maxcode = MAXCODE(zs->zs_n_bits = INIT_BITS);
512 for (zs->zs_code = 255; zs->zs_code >= 0; zs->zs_code--) {
513 tab_prefixof(zs->zs_code) = 0;
514 tab_suffixof(zs->zs_code) = (u_char) zs->zs_code;
516 zs->zs_free_ent = zs->zs_block_compress ? FIRST : 256;
518 zs->zs_finchar = zs->zs_oldcode = getcode(zs);
519 if (zs->zs_oldcode == -1) /* EOF already? */
523 *bp++ = (u_char)zs->zs_finchar;
525 zs->zs_stackp = de_stack;
527 while ((zs->zs_code = getcode(zs)) > -1) {
529 if ((zs->zs_code == CLEAR) && zs->zs_block_compress) {
530 for (zs->zs_code = 255; zs->zs_code >= 0;
531 zs->zs_code--)
532 tab_prefixof(zs->zs_code) = 0;
533 zs->zs_clear_flg = 1;
534 zs->zs_free_ent = FIRST - 1;
535 if ((zs->zs_code = getcode(zs)) == -1) /* O, untimely death! */
538 zs->zs_incode = zs->zs_code;
541 if (zs->zs_code >= zs->zs_free_ent) {
542 *zs->zs_stackp++ = zs->zs_finchar;
543 zs->zs_code = zs->zs_oldcode;
547 while (zs->zs_code >= 256) {
553 if (zs->zs_stackp >= (u_char *)&zs->zs_htab[HSIZE]) {
557 *zs->zs_stackp++ = tab_suffixof(zs->zs_code);
558 zs->zs_code = tab_prefixof(zs->zs_code);
560 *zs->zs_stackp++ = zs->zs_finchar = tab_suffixof(zs->zs_code);
565 zs->zs_bytes_out += num;
568 *bp++ = *--zs->zs_stackp;
569 } while (zs->zs_stackp > de_stack);
572 if ((zs->zs_code = zs->zs_free_ent) < zs->zs_maxmaxcode) {
573 tab_prefixof(zs->zs_code) = (u_short) zs->zs_oldcode;
574 tab_suffixof(zs->zs_code) = zs->zs_finchar;
575 zs->zs_free_ent = zs->zs_code + 1;
579 zs->zs_oldcode = zs->zs_incode;
581 zs->zs_state = S_EOF;
582 zs->zs_bytes_out += num - count;
594 getcode(struct s_zstate *zs)
600 if (zs->zs_clear_flg > 0 || zs->zs_offset >= zs->zs_size ||
601 zs->zs_free_ent > zs->zs_maxcode) {
603 zs->zs_bp += zs->zs_n_bits;
609 if (zs->zs_free_ent > zs->zs_maxcode) {
610 zs->zs_n_bits++;
611 if (zs->zs_n_bits == zs->zs_maxbits) {
613 zs->zs_maxcode = zs->zs_maxmaxcode;
615 zs->zs_maxcode = MAXCODE(zs->zs_n_bits);
617 if (zs->zs_clear_flg > 0) {
618 zs->zs_maxcode = MAXCODE(zs->zs_n_bits = INIT_BITS);
619 zs->zs_clear_flg = 0;
623 if (zs->zs_bp + zs->zs_n_bits > zs->zs_ebp) {
624 for (bp = zs->zs_buf; zs->zs_bp < zs->zs_ebp;
625 *bp++ = *zs->zs_bp++);
626 if ((bits = read(zs->zs_fd, bp, ZBUFSIZ -
627 (bp - zs->zs_buf))) < 0)
629 zs->zs_in_count += bits;
630 zs->zs_bp = zs->zs_buf;
631 zs->zs_ebp = bp + bits;
633 zs->zs_offset = 0;
634 zs->zs_size = MINIMUM(zs->zs_n_bits, zs->zs_ebp - zs->zs_bp);
635 if (zs->zs_size == 0)
638 zs->zs_size = (zs->zs_size << 3) - (zs->zs_n_bits - 1);
641 bp = zs->zs_bp;
642 r_off = zs->zs_offset;
643 bits = zs->zs_n_bits;
663 zs->zs_offset += zs->zs_n_bits;
670 cl_block(struct s_zstate *zs)
674 zs->zs_checkpoint = zs->zs_in_count + CHECK_GAP;
676 if (zs->zs_in_count > 0x007fffff) { /* Shift will overflow. */
677 rat = zs->zs_bytes_out >> 8;
681 rat = zs->zs_in_count / rat;
684 rat = (zs->zs_in_count << 8) / zs->zs_bytes_out;
686 if (rat > zs->zs_ratio)
687 zs->zs_ratio = rat;
689 zs->zs_ratio = 0;
690 cl_hash(zs, (count_int) zs->zs_hsize);
691 zs->zs_free_ent = FIRST;
692 zs->zs_clear_flg = 1;
693 if (output(zs, (code_int) CLEAR) == -1)
701 cl_hash(struct s_zstate *zs, count_int cl_hsize)
707 htab_p = zs->zs_htab + cl_hsize;
735 struct s_zstate *zs;
742 if ((zs = calloc(1, sizeof(struct s_zstate))) == NULL)
746 zs->zs_maxbits = bits ? bits : BITS;
748 zs->zs_maxmaxcode = 1 << zs->zs_maxbits;
749 zs->zs_hsize = HSIZE; /* For dynamic table sizing. */
750 zs->zs_free_ent = 0; /* First unused entry. */
751 zs->zs_block_compress = BLOCK_MASK;
752 zs->zs_clear_flg = 0;
753 zs->zs_ratio = 0;
754 zs->zs_checkpoint = CHECK_GAP;
755 zs->zs_in_count = 0; /* Length of input. */
756 zs->zs_out_count = 0; /* # of codes output (for debugging).*/
757 zs->zs_state = S_START;
758 zs->zs_offset = 0;
759 zs->zs_size = 0;
760 zs->zs_mode = 'w';
761 zs->zs_bp = zs->zs_ebp = zs->zs_buf;
763 zs->zs_fd = fd;
764 return zs;
770 struct s_zstate *zs;
772 if ((zs = calloc(1, sizeof(struct s_zstate))) == NULL)
776 zs->zs_maxbits = BITS;
778 zs->zs_maxmaxcode = 1 << zs->zs_maxbits;
779 zs->zs_hsize = HSIZE; /* For dynamic table sizing. */
780 zs->zs_free_ent = 0; /* First unused entry. */
781 zs->zs_block_compress = BLOCK_MASK;
782 zs->zs_clear_flg = 0;
783 zs->zs_ratio = 0;
784 zs->zs_checkpoint = CHECK_GAP;
785 zs->zs_in_count = 0; /* Length of input. */
786 zs->zs_out_count = 0; /* # of codes output (for debugging).*/
787 zs->zs_state = gotmagic ? S_MAGIC : S_START;
788 zs->zs_offset = 0;
789 zs->zs_size = 0;
790 zs->zs_mode = 'r';
791 zs->zs_bp = zs->zs_ebp = zs->zs_buf;
793 zs->zs_fd = fd;
794 return zs;