Lines Matching refs:state
95 local void fixedtables OF((struct inflate_state FAR *state));
107 struct inflate_state FAR *state; local
109 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
110 state = (struct inflate_state FAR *)strm->state;
111 strm->total_in = strm->total_out = state->total = 0;
113 if (state->wrap) /* to support ill-conceived Java test suite */
114 strm->adler = state->wrap & 1;
115 state->mode = HEAD;
116 state->last = 0;
117 state->havedict = 0;
118 state->dmax = 32768U;
119 state->head = Z_NULL;
120 state->hold = 0;
121 state->bits = 0;
122 state->lencode = state->distcode = state->next = state->codes;
123 state->sane = 1;
124 state->back = -1;
132 struct inflate_state FAR *state; local
134 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
135 state = (struct inflate_state FAR *)strm->state;
136 state->wsize = 0;
137 state->whave = 0;
138 state->wnext = 0;
147 struct inflate_state FAR *state; local
150 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
151 state = (struct inflate_state FAR *)strm->state;
169 if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
170 ZFREE(strm, state->window);
171 state->window = Z_NULL;
175 state->wrap = wrap;
176 state->wbits = (unsigned)windowBits;
187 struct inflate_state FAR *state; local
208 state = (struct inflate_state FAR *)
210 if (state == Z_NULL) return Z_MEM_ERROR;
212 strm->state = (struct internal_state FAR *)state;
213 state->window = Z_NULL;
216 ZFREE(strm, state);
217 strm->state = Z_NULL;
235 struct inflate_state FAR *state; local
237 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
238 state = (struct inflate_state FAR *)strm->state;
240 state->hold = 0;
241 state->bits = 0;
244 if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
246 state->hold += value << state->bits;
247 state->bits += bits;
261 local void fixedtables(state) in fixedtables() argument
262 struct inflate_state FAR *state; in fixedtables()
276 while (sym < 144) state->lens[sym++] = 8;
277 while (sym < 256) state->lens[sym++] = 9;
278 while (sym < 280) state->lens[sym++] = 7;
279 while (sym < 288) state->lens[sym++] = 8;
283 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
287 while (sym < 32) state->lens[sym++] = 5;
290 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
298 state->lencode = lenfix;
299 state->lenbits = 9;
300 state->distcode = distfix;
301 state->distbits = 5;
328 struct inflate_state state; in makefixed() local
330 fixedtables(&state); in makefixed()
345 printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, in makefixed()
346 state.lencode[low].bits, state.lencode[low].val); in makefixed()
356 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, in makefixed()
357 state.distcode[low].val); in makefixed()
384 struct inflate_state FAR *state; local
387 state = (struct inflate_state FAR *)strm->state;
390 if (state->window == Z_NULL) {
391 state->window = (unsigned char FAR *)
392 ZALLOC(strm, 1U << state->wbits,
394 if (state->window == Z_NULL) return 1;
398 if (state->wsize == 0) {
399 state->wsize = 1U << state->wbits;
400 state->wnext = 0;
401 state->whave = 0;
405 if (copy >= state->wsize) {
406 zmemcpy(state->window, end - state->wsize, state->wsize);
407 state->wnext = 0;
408 state->whave = state->wsize;
411 dist = state->wsize - state->wnext;
413 zmemcpy(state->window + state->wnext, end - copy, dist);
416 zmemcpy(state->window, end - copy, copy);
417 state->wnext = copy;
418 state->whave = state->wsize;
421 state->wnext += dist;
422 if (state->wnext == state->wsize) state->wnext = 0;
423 if (state->whave < state->wsize) state->whave += dist;
434 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
465 hold = state->hold; \
466 bits = state->bits; \
476 state->hold = hold; \
477 state->bits = bits; \
609 struct inflate_state FAR *state; local
628 if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
632 state = (struct inflate_state FAR *)strm->state;
633 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
639 switch (state->mode) {
641 if (state->wrap == 0) {
642 state->mode = TYPEDO;
647 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
648 state->check = crc32(0L, Z_NULL, 0);
649 CRC2(state->check, hold);
651 state->mode = FLAGS;
654 state->flags = 0; /* expect zlib header */
655 if (state->head != Z_NULL)
656 state->head->done = -1;
657 if (!(state->wrap & 1) || /* check if zlib header allowed */
663 state->mode = BAD;
668 state->mode = BAD;
673 if (state->wbits == 0)
674 state->wbits = len;
675 else if (len > state->wbits) {
677 state->mode = BAD;
680 state->dmax = 1U << len;
682 strm->adler = state->check = adler32(0L, Z_NULL, 0);
683 state->mode = hold & 0x200 ? DICTID : TYPE;
689 state->flags = (int)(hold);
690 if ((state->flags & 0xff) != Z_DEFLATED) {
692 state->mode = BAD;
695 if (state->flags & 0xe000) {
697 state->mode = BAD;
700 if (state->head != Z_NULL)
701 state->head->text = (int)((hold >> 8) & 1);
702 if (state->flags & 0x0200) CRC2(state->check, hold);
704 state->mode = TIME;
707 if (state->head != Z_NULL)
708 state->head->time = hold;
709 if (state->flags & 0x0200) CRC4(state->check, hold);
711 state->mode = OS;
714 if (state->head != Z_NULL) {
715 state->head->xflags = (int)(hold & 0xff);
716 state->head->os = (int)(hold >> 8);
718 if (state->flags & 0x0200) CRC2(state->check, hold);
720 state->mode = EXLEN;
722 if (state->flags & 0x0400) {
724 state->length = (unsigned)(hold);
725 if (state->head != Z_NULL)
726 state->head->extra_len = (unsigned)hold;
727 if (state->flags & 0x0200) CRC2(state->check, hold);
730 else if (state->head != Z_NULL)
731 state->head->extra = Z_NULL;
732 state->mode = EXTRA;
734 if (state->flags & 0x0400) {
735 copy = state->length;
738 if (state->head != Z_NULL &&
739 state->head->extra != Z_NULL) {
740 len = state->head->extra_len - state->length;
741 zmemcpy(state->head->extra + len, next,
742 len + copy > state->head->extra_max ?
743 state->head->extra_max - len : copy);
745 if (state->flags & 0x0200)
746 state->check = crc32(state->check, next, copy);
749 state->length -= copy;
751 if (state->length) goto inf_leave;
753 state->length = 0;
754 state->mode = NAME;
756 if (state->flags & 0x0800) {
761 if (state->head != Z_NULL &&
762 state->head->name != Z_NULL &&
763 state->length < state->head->name_max)
764 state->head->name[state->length++] = len;
766 if (state->flags & 0x0200)
767 state->check = crc32(state->check, next, copy);
772 else if (state->head != Z_NULL)
773 state->head->name = Z_NULL;
774 state->length = 0;
775 state->mode = COMMENT;
777 if (state->flags & 0x1000) {
782 if (state->head != Z_NULL &&
783 state->head->comment != Z_NULL &&
784 state->length < state->head->comm_max)
785 state->head->comment[state->length++] = len;
787 if (state->flags & 0x0200)
788 state->check = crc32(state->check, next, copy);
793 else if (state->head != Z_NULL)
794 state->head->comment = Z_NULL;
795 state->mode = HCRC;
797 if (state->flags & 0x0200) {
799 if (hold != (state->check & 0xffff)) {
801 state->mode = BAD;
806 if (state->head != Z_NULL) {
807 state->head->hcrc = (int)((state->flags >> 9) & 1);
808 state->head->done = 1;
810 strm->adler = state->check = crc32(0L, Z_NULL, 0);
811 state->mode = TYPE;
816 strm->adler = state->check = ZSWAP32(hold);
818 state->mode = DICT;
820 if (state->havedict == 0) {
824 strm->adler = state->check = adler32(0L, Z_NULL, 0);
825 state->mode = TYPE;
829 if (state->last) {
831 state->mode = CHECK;
835 state->last = BITS(1);
840 state->last ? " (last)" : ""));
841 state->mode = STORED;
844 fixedtables(state);
846 state->last ? " (last)" : ""));
847 state->mode = LEN_; /* decode codes */
855 state->last ? " (last)" : ""));
856 state->mode = TABLE;
860 state->mode = BAD;
869 state->mode = BAD;
872 state->length = (unsigned)hold & 0xffff;
874 state->length));
876 state->mode = COPY_;
879 state->mode = COPY;
881 copy = state->length;
891 state->length -= copy;
895 state->mode = TYPE;
899 state->nlen = BITS(5) + 257;
901 state->ndist = BITS(5) + 1;
903 state->ncode = BITS(4) + 4;
906 if (state->nlen > 286 || state->ndist > 30) {
908 state->mode = BAD;
913 state->have = 0;
914 state->mode = LENLENS;
916 while (state->have < state->ncode) {
918 state->lens[order[state->have++]] = (unsigned short)BITS(3);
921 while (state->have < 19)
922 state->lens[order[state->have++]] = 0;
923 state->next = state->codes;
924 state->lencode = (const code FAR *)(state->next);
925 state->lenbits = 7;
926 ret = inflate_table(CODES, state->lens, 19, &(state->next),
927 &(state->lenbits), state->work);
930 state->mode = BAD;
934 state->have = 0;
935 state->mode = CODELENS;
937 while (state->have < state->nlen + state->ndist) {
939 here = state->lencode[BITS(state->lenbits)];
945 state->lens[state->have++] = here.val;
951 if (state->have == 0) {
953 state->mode = BAD;
956 len = state->lens[state->have - 1];
974 if (state->have + copy > state->nlen + state->ndist) {
976 state->mode = BAD;
980 state->lens[state->have++] = (unsigned short)len;
985 if (state->mode == BAD) break;
988 if (state->lens[256] == 0) {
990 state->mode = BAD;
997 state->next = state->codes;
998 state->lencode = (const code FAR *)(state->next);
999 state->lenbits = 9;
1000 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1001 &(state->lenbits), state->work);
1004 state->mode = BAD;
1007 state->distcode = (const code FAR *)(state->next);
1008 state->distbits = 6;
1009 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1010 &(state->next), &(state->distbits), state->work);
1013 state->mode = BAD;
1017 state->mode = LEN_;
1020 state->mode = LEN;
1026 if (state->mode == TYPE)
1027 state->back = -1;
1030 state->back = 0;
1032 here = state->lencode[BITS(state->lenbits)];
1039 here = state->lencode[last.val +
1045 state->back += last.bits;
1048 state->back += here.bits;
1049 state->length = (unsigned)here.val;
1054 state->mode = LIT;
1059 state->back = -1;
1060 state->mode = TYPE;
1065 state->mode = BAD;
1068 state->extra = (unsigned)(here.op) & 15;
1069 state->mode = LENEXT;
1071 if (state->extra) {
1072 NEEDBITS(state->extra);
1073 state->length += BITS(state->extra);
1074 DROPBITS(state->extra);
1075 state->back += state->extra;
1077 Tracevv((stderr, "inflate: length %u\n", state->length));
1078 state->was = state->length;
1079 state->mode = DIST;
1082 here = state->distcode[BITS(state->distbits)];
1089 here = state->distcode[last.val +
1095 state->back += last.bits;
1098 state->back += here.bits;
1101 state->mode = BAD;
1104 state->offset = (unsigned)here.val;
1105 state->extra = (unsigned)(here.op) & 15;
1106 state->mode = DISTEXT;
1108 if (state->extra) {
1109 NEEDBITS(state->extra);
1110 state->offset += BITS(state->extra);
1111 DROPBITS(state->extra);
1112 state->back += state->extra;
1115 if (state->offset > state->dmax) {
1117 state->mode = BAD;
1121 Tracevv((stderr, "inflate: distance %u\n", state->offset));
1122 state->mode = MATCH;
1126 if (state->offset > copy) { /* copy from window */
1127 copy = state->offset - copy;
1128 if (copy > state->whave) {
1129 if (state->sane) {
1131 state->mode = BAD;
1136 copy -= state->whave;
1137 if (copy > state->length) copy = state->length;
1140 state->length -= copy;
1144 if (state->length == 0) state->mode = LEN;
1148 if (copy > state->wnext) {
1149 copy -= state->wnext;
1150 from = state->window + (state->wsize - copy);
1153 from = state->window + (state->wnext - copy);
1154 if (copy > state->length) copy = state->length;
1157 from = put - state->offset;
1158 copy = state->length;
1162 state->length -= copy;
1166 if (state->length == 0) state->mode = LEN;
1170 *put++ = (unsigned char)(state->length);
1172 state->mode = LEN;
1175 if (state->wrap) {
1179 state->total += out;
1181 strm->adler = state->check =
1182 UPDATE(state->check, put - out, out);
1186 state->flags ? hold :
1188 ZSWAP32(hold)) != state->check) {
1190 state->mode = BAD;
1197 state->mode = LENGTH;
1199 if (state->wrap && state->flags) {
1201 if (hold != (state->total & 0xffffffffUL)) {
1203 state->mode = BAD;
1210 state->mode = DONE;
1232 if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
1233 (state->mode < CHECK || flush != Z_FINISH)))
1235 state->mode = MEM;
1242 state->total += out;
1243 if (state->wrap && out)
1244 strm->adler = state->check =
1245 UPDATE(state->check, strm->next_out - out, out);
1246 strm->data_type = state->bits + (state->last ? 64 : 0) +
1247 (state->mode == TYPE ? 128 : 0) +
1248 (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
1257 struct inflate_state FAR *state; local
1258 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1260 state = (struct inflate_state FAR *)strm->state;
1261 if (state->window != Z_NULL) ZFREE(strm, state->window);
1262 ZFREE(strm, strm->state);
1263 strm->state = Z_NULL;
1273 struct inflate_state FAR *state; local
1276 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1277 state = (struct inflate_state FAR *)strm->state;
1280 if (state->whave && dictionary != Z_NULL) {
1281 zmemcpy(dictionary, state->window + state->wnext,
1282 state->whave - state->wnext);
1283 zmemcpy(dictionary + state->whave - state->wnext,
1284 state->window, state->wnext);
1287 *dictLength = state->whave;
1296 struct inflate_state FAR *state; local
1301 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1302 state = (struct inflate_state FAR *)strm->state;
1303 if (state->wrap != 0 && state->mode != DICT)
1307 if (state->mode == DICT) {
1310 if (dictid != state->check)
1318 state->mode = MEM;
1321 state->havedict = 1;
1330 struct inflate_state FAR *state; local
1333 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1334 state = (struct inflate_state FAR *)strm->state;
1335 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1338 state->head = head;
1383 struct inflate_state FAR *state; local
1386 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1387 state = (struct inflate_state FAR *)strm->state;
1388 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1391 if (state->mode != SYNC) {
1392 state->mode = SYNC;
1393 state->hold <<= state->bits & 7;
1394 state->bits -= state->bits & 7;
1396 while (state->bits >= 8) {
1397 buf[len++] = (unsigned char)(state->hold);
1398 state->hold >>= 8;
1399 state->bits -= 8;
1401 state->have = 0;
1402 syncsearch(&(state->have), buf, len);
1406 len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1412 if (state->have != 4) return Z_DATA_ERROR;
1416 state->mode = TYPE;
1431 struct inflate_state FAR *state; local
1433 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1434 state = (struct inflate_state FAR *)strm->state;
1435 return state->mode == STORED && state->bits == 0;
1442 struct inflate_state FAR *state; local
1448 if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1451 state = (struct inflate_state FAR *)source->state;
1458 if (state->window != Z_NULL) {
1460 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1469 zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
1470 if (state->lencode >= state->codes &&
1471 state->lencode <= state->codes + ENOUGH - 1) {
1472 copy->lencode = copy->codes + (state->lencode - state->codes);
1473 copy->distcode = copy->codes + (state->distcode - state->codes);
1475 copy->next = copy->codes + (state->next - state->codes);
1477 wsize = 1U << state->wbits;
1478 zmemcpy(window, state->window, wsize);
1481 dest->state = (struct internal_state FAR *)copy;
1489 struct inflate_state FAR *state; local
1491 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1492 state = (struct inflate_state FAR *)strm->state;
1493 state->sane = !subvert;
1497 state->sane = 1;
1505 struct inflate_state FAR *state; local
1507 if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
1508 state = (struct inflate_state FAR *)strm->state;
1509 return ((long)(state->back) << 16) +
1510 (state->mode == COPY ? state->length :
1511 (state->mode == MATCH ? state->was - state->length : 0));