Lines Matching refs:state
96 local void fixedtables OF((struct inflate_state FAR *state));
108 struct inflate_state FAR *state; local
112 state = (struct inflate_state FAR *)strm->state;
113 if (state == Z_NULL || state->strm != strm ||
114 state->mode < HEAD || state->mode > SYNC)
122 struct inflate_state FAR *state; local
125 state = (struct inflate_state FAR *)strm->state;
126 strm->total_in = strm->total_out = state->total = 0;
128 if (state->wrap) /* to support ill-conceived Java test suite */
129 strm->adler = state->wrap & 1;
130 state->mode = HEAD;
131 state->last = 0;
132 state->havedict = 0;
133 state->dmax = 32768U;
134 state->head = Z_NULL;
135 state->hold = 0;
136 state->bits = 0;
137 state->lencode = state->distcode = state->next = state->codes;
138 state->sane = 1;
139 state->back = -1;
147 struct inflate_state FAR *state; local
150 state = (struct inflate_state FAR *)strm->state;
151 state->wsize = 0;
152 state->whave = 0;
153 state->wnext = 0;
162 struct inflate_state FAR *state; local
166 state = (struct inflate_state FAR *)strm->state;
184 if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
185 ZFREE(strm, state->window);
186 state->window = Z_NULL;
190 state->wrap = wrap;
191 state->wbits = (unsigned)windowBits;
202 struct inflate_state FAR *state; local
223 state = (struct inflate_state FAR *)
225 if (state == Z_NULL) return Z_MEM_ERROR;
227 strm->state = (struct internal_state FAR *)state;
228 state->strm = strm;
229 state->window = Z_NULL;
230 state->mode = HEAD; /* to pass state test in inflateReset2() */
233 ZFREE(strm, state);
234 strm->state = Z_NULL;
252 struct inflate_state FAR *state; local
255 state = (struct inflate_state FAR *)strm->state;
257 state->hold = 0;
258 state->bits = 0;
261 if (bits > 16 || state->bits + (uInt)bits > 32) return Z_STREAM_ERROR;
263 state->hold += (unsigned)value << state->bits;
264 state->bits += (uInt)bits;
278 local void fixedtables(state) in fixedtables() argument
279 struct inflate_state FAR *state; in fixedtables()
293 while (sym < 144) state->lens[sym++] = 8;
294 while (sym < 256) state->lens[sym++] = 9;
295 while (sym < 280) state->lens[sym++] = 7;
296 while (sym < 288) state->lens[sym++] = 8;
300 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
304 while (sym < 32) state->lens[sym++] = 5;
307 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
315 state->lencode = lenfix;
316 state->lenbits = 9;
317 state->distcode = distfix;
318 state->distbits = 5;
345 struct inflate_state state; in makefixed() local
347 fixedtables(&state); in makefixed()
362 printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, in makefixed()
363 state.lencode[low].bits, state.lencode[low].val); in makefixed()
373 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, in makefixed()
374 state.distcode[low].val); in makefixed()
401 struct inflate_state FAR *state; local
404 state = (struct inflate_state FAR *)strm->state;
407 if (state->window == Z_NULL) {
408 state->window = (unsigned char FAR *)
409 ZALLOC(strm, 1U << state->wbits,
411 if (state->window == Z_NULL) return 1;
415 if (state->wsize == 0) {
416 state->wsize = 1U << state->wbits;
417 state->wnext = 0;
418 state->whave = 0;
422 if (copy >= state->wsize) {
423 zmemcpy(state->window, end - state->wsize, state->wsize);
424 state->wnext = 0;
425 state->whave = state->wsize;
428 dist = state->wsize - state->wnext;
430 zmemcpy(state->window + state->wnext, end - copy, dist);
433 zmemcpy(state->window, end - copy, copy);
434 state->wnext = copy;
435 state->whave = state->wsize;
438 state->wnext += dist;
439 if (state->wnext == state->wsize) state->wnext = 0;
440 if (state->whave < state->wsize) state->whave += dist;
451 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
482 hold = state->hold; \
483 bits = state->bits; \
493 state->hold = hold; \
494 state->bits = bits; \
626 struct inflate_state FAR *state; local
649 state = (struct inflate_state FAR *)strm->state;
650 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
656 switch (state->mode) {
658 if (state->wrap == 0) {
659 state->mode = TYPEDO;
664 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
665 if (state->wbits == 0)
666 state->wbits = 15;
667 state->check = crc32(0L, Z_NULL, 0);
668 CRC2(state->check, hold);
670 state->mode = FLAGS;
673 state->flags = 0; /* expect zlib header */
674 if (state->head != Z_NULL)
675 state->head->done = -1;
676 if (!(state->wrap & 1) || /* check if zlib header allowed */
682 state->mode = BAD;
687 state->mode = BAD;
692 if (state->wbits == 0)
693 state->wbits = len;
694 if (len > 15 || len > state->wbits) {
696 state->mode = BAD;
699 state->dmax = 1U << len;
701 strm->adler = state->check = adler32(0L, Z_NULL, 0);
702 state->mode = hold & 0x200 ? DICTID : TYPE;
708 state->flags = (int)(hold);
709 if ((state->flags & 0xff) != Z_DEFLATED) {
711 state->mode = BAD;
714 if (state->flags & 0xe000) {
716 state->mode = BAD;
719 if (state->head != Z_NULL)
720 state->head->text = (int)((hold >> 8) & 1);
721 if ((state->flags & 0x0200) && (state->wrap & 4))
722 CRC2(state->check, hold);
724 state->mode = TIME;
727 if (state->head != Z_NULL)
728 state->head->time = hold;
729 if ((state->flags & 0x0200) && (state->wrap & 4))
730 CRC4(state->check, hold);
732 state->mode = OS;
735 if (state->head != Z_NULL) {
736 state->head->xflags = (int)(hold & 0xff);
737 state->head->os = (int)(hold >> 8);
739 if ((state->flags & 0x0200) && (state->wrap & 4))
740 CRC2(state->check, hold);
742 state->mode = EXLEN;
744 if (state->flags & 0x0400) {
746 state->length = (unsigned)(hold);
747 if (state->head != Z_NULL)
748 state->head->extra_len = (unsigned)hold;
749 if ((state->flags & 0x0200) && (state->wrap & 4))
750 CRC2(state->check, hold);
753 else if (state->head != Z_NULL)
754 state->head->extra = Z_NULL;
755 state->mode = EXTRA;
757 if (state->flags & 0x0400) {
758 copy = state->length;
761 if (state->head != Z_NULL &&
762 state->head->extra != Z_NULL) {
763 len = state->head->extra_len - state->length;
764 zmemcpy(state->head->extra + len, next,
765 len + copy > state->head->extra_max ?
766 state->head->extra_max - len : copy);
768 if ((state->flags & 0x0200) && (state->wrap & 4))
769 state->check = crc32(state->check, next, copy);
772 state->length -= copy;
774 if (state->length) goto inf_leave;
776 state->length = 0;
777 state->mode = NAME;
779 if (state->flags & 0x0800) {
784 if (state->head != Z_NULL &&
785 state->head->name != Z_NULL &&
786 state->length < state->head->name_max)
787 state->head->name[state->length++] = (Bytef)len;
789 if ((state->flags & 0x0200) && (state->wrap & 4))
790 state->check = crc32(state->check, next, copy);
795 else if (state->head != Z_NULL)
796 state->head->name = Z_NULL;
797 state->length = 0;
798 state->mode = COMMENT;
800 if (state->flags & 0x1000) {
805 if (state->head != Z_NULL &&
806 state->head->comment != Z_NULL &&
807 state->length < state->head->comm_max)
808 state->head->comment[state->length++] = (Bytef)len;
810 if ((state->flags & 0x0200) && (state->wrap & 4))
811 state->check = crc32(state->check, next, copy);
816 else if (state->head != Z_NULL)
817 state->head->comment = Z_NULL;
818 state->mode = HCRC;
820 if (state->flags & 0x0200) {
822 if ((state->wrap & 4) && hold != (state->check & 0xffff)) {
824 state->mode = BAD;
829 if (state->head != Z_NULL) {
830 state->head->hcrc = (int)((state->flags >> 9) & 1);
831 state->head->done = 1;
833 strm->adler = state->check = crc32(0L, Z_NULL, 0);
834 state->mode = TYPE;
839 strm->adler = state->check = ZSWAP32(hold);
841 state->mode = DICT;
843 if (state->havedict == 0) {
847 strm->adler = state->check = adler32(0L, Z_NULL, 0);
848 state->mode = TYPE;
852 if (state->last) {
854 state->mode = CHECK;
858 state->last = BITS(1);
863 state->last ? " (last)" : ""));
864 state->mode = STORED;
867 fixedtables(state);
869 state->last ? " (last)" : ""));
870 state->mode = LEN_; /* decode codes */
878 state->last ? " (last)" : ""));
879 state->mode = TABLE;
883 state->mode = BAD;
892 state->mode = BAD;
895 state->length = (unsigned)hold & 0xffff;
897 state->length));
899 state->mode = COPY_;
902 state->mode = COPY;
904 copy = state->length;
914 state->length -= copy;
918 state->mode = TYPE;
922 state->nlen = BITS(5) + 257;
924 state->ndist = BITS(5) + 1;
926 state->ncode = BITS(4) + 4;
929 if (state->nlen > 286 || state->ndist > 30) {
931 state->mode = BAD;
936 state->have = 0;
937 state->mode = LENLENS;
939 while (state->have < state->ncode) {
941 state->lens[order[state->have++]] = (unsigned short)BITS(3);
944 while (state->have < 19)
945 state->lens[order[state->have++]] = 0;
946 state->next = state->codes;
947 state->lencode = (const code FAR *)(state->next);
948 state->lenbits = 7;
949 ret = inflate_table(CODES, state->lens, 19, &(state->next),
950 &(state->lenbits), state->work);
953 state->mode = BAD;
957 state->have = 0;
958 state->mode = CODELENS;
960 while (state->have < state->nlen + state->ndist) {
962 here = state->lencode[BITS(state->lenbits)];
968 state->lens[state->have++] = here.val;
974 if (state->have == 0) {
976 state->mode = BAD;
979 len = state->lens[state->have - 1];
997 if (state->have + copy > state->nlen + state->ndist) {
999 state->mode = BAD;
1003 state->lens[state->have++] = (unsigned short)len;
1008 if (state->mode == BAD) break;
1011 if (state->lens[256] == 0) {
1013 state->mode = BAD;
1020 state->next = state->codes;
1021 state->lencode = (const code FAR *)(state->next);
1022 state->lenbits = 9;
1023 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1024 &(state->lenbits), state->work);
1027 state->mode = BAD;
1030 state->distcode = (const code FAR *)(state->next);
1031 state->distbits = 6;
1032 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1033 &(state->next), &(state->distbits), state->work);
1036 state->mode = BAD;
1040 state->mode = LEN_;
1043 state->mode = LEN;
1049 if (state->mode == TYPE)
1050 state->back = -1;
1053 state->back = 0;
1055 here = state->lencode[BITS(state->lenbits)];
1062 here = state->lencode[last.val +
1068 state->back += last.bits;
1071 state->back += here.bits;
1072 state->length = (unsigned)here.val;
1077 state->mode = LIT;
1082 state->back = -1;
1083 state->mode = TYPE;
1088 state->mode = BAD;
1091 state->extra = (unsigned)(here.op) & 15;
1092 state->mode = LENEXT;
1094 if (state->extra) {
1095 NEEDBITS(state->extra);
1096 state->length += BITS(state->extra);
1097 DROPBITS(state->extra);
1098 state->back += state->extra;
1100 Tracevv((stderr, "inflate: length %u\n", state->length));
1101 state->was = state->length;
1102 state->mode = DIST;
1105 here = state->distcode[BITS(state->distbits)];
1112 here = state->distcode[last.val +
1118 state->back += last.bits;
1121 state->back += here.bits;
1124 state->mode = BAD;
1127 state->offset = (unsigned)here.val;
1128 state->extra = (unsigned)(here.op) & 15;
1129 state->mode = DISTEXT;
1131 if (state->extra) {
1132 NEEDBITS(state->extra);
1133 state->offset += BITS(state->extra);
1134 DROPBITS(state->extra);
1135 state->back += state->extra;
1138 if (state->offset > state->dmax) {
1140 state->mode = BAD;
1144 Tracevv((stderr, "inflate: distance %u\n", state->offset));
1145 state->mode = MATCH;
1149 if (state->offset > copy) { /* copy from window */
1150 copy = state->offset - copy;
1151 if (copy > state->whave) {
1152 if (state->sane) {
1154 state->mode = BAD;
1159 copy -= state->whave;
1160 if (copy > state->length) copy = state->length;
1163 state->length -= copy;
1167 if (state->length == 0) state->mode = LEN;
1171 if (copy > state->wnext) {
1172 copy -= state->wnext;
1173 from = state->window + (state->wsize - copy);
1176 from = state->window + (state->wnext - copy);
1177 if (copy > state->length) copy = state->length;
1180 from = put - state->offset;
1181 copy = state->length;
1185 state->length -= copy;
1189 if (state->length == 0) state->mode = LEN;
1193 *put++ = (unsigned char)(state->length);
1195 state->mode = LEN;
1198 if (state->wrap) {
1202 state->total += out;
1203 if ((state->wrap & 4) && out)
1204 strm->adler = state->check =
1205 UPDATE(state->check, put - out, out);
1207 if ((state->wrap & 4) && (
1209 state->flags ? hold :
1211 ZSWAP32(hold)) != state->check) {
1213 state->mode = BAD;
1220 state->mode = LENGTH;
1222 if (state->wrap && state->flags) {
1224 if (hold != (state->total & 0xffffffffUL)) {
1226 state->mode = BAD;
1233 state->mode = DONE;
1255 if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
1256 (state->mode < CHECK || flush != Z_FINISH)))
1258 state->mode = MEM;
1265 state->total += out;
1266 if ((state->wrap & 4) && out)
1267 strm->adler = state->check =
1268 UPDATE(state->check, strm->next_out - out, out);
1269 strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
1270 (state->mode == TYPE ? 128 : 0) +
1271 (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
1280 struct inflate_state FAR *state; local
1283 state = (struct inflate_state FAR *)strm->state;
1284 if (state->window != Z_NULL) ZFREE(strm, state->window);
1285 ZFREE(strm, strm->state);
1286 strm->state = Z_NULL;
1296 struct inflate_state FAR *state; local
1300 state = (struct inflate_state FAR *)strm->state;
1303 if (state->whave && dictionary != Z_NULL) {
1304 zmemcpy(dictionary, state->window + state->wnext,
1305 state->whave - state->wnext);
1306 zmemcpy(dictionary + state->whave - state->wnext,
1307 state->window, state->wnext);
1310 *dictLength = state->whave;
1319 struct inflate_state FAR *state; local
1325 state = (struct inflate_state FAR *)strm->state;
1326 if (state->wrap != 0 && state->mode != DICT)
1330 if (state->mode == DICT) {
1333 if (dictid != state->check)
1341 state->mode = MEM;
1344 state->havedict = 1;
1353 struct inflate_state FAR *state; local
1357 state = (struct inflate_state FAR *)strm->state;
1358 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1361 state->head = head;
1406 struct inflate_state FAR *state; local
1410 state = (struct inflate_state FAR *)strm->state;
1411 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1414 if (state->mode != SYNC) {
1415 state->mode = SYNC;
1416 state->hold <<= state->bits & 7;
1417 state->bits -= state->bits & 7;
1419 while (state->bits >= 8) {
1420 buf[len++] = (unsigned char)(state->hold);
1421 state->hold >>= 8;
1422 state->bits -= 8;
1424 state->have = 0;
1425 syncsearch(&(state->have), buf, len);
1429 len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1435 if (state->have != 4) return Z_DATA_ERROR;
1439 state->mode = TYPE;
1454 struct inflate_state FAR *state; local
1457 state = (struct inflate_state FAR *)strm->state;
1458 return state->mode == STORED && state->bits == 0;
1465 struct inflate_state FAR *state; local
1473 state = (struct inflate_state FAR *)source->state;
1480 if (state->window != Z_NULL) {
1482 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1491 zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
1493 if (state->lencode >= state->codes &&
1494 state->lencode <= state->codes + ENOUGH - 1) {
1495 copy->lencode = copy->codes + (state->lencode - state->codes);
1496 copy->distcode = copy->codes + (state->distcode - state->codes);
1498 copy->next = copy->codes + (state->next - state->codes);
1500 wsize = 1U << state->wbits;
1501 zmemcpy(window, state->window, wsize);
1504 dest->state = (struct internal_state FAR *)copy;
1512 struct inflate_state FAR *state; local
1515 state = (struct inflate_state FAR *)strm->state;
1517 state->sane = !subvert;
1521 state->sane = 1;
1530 struct inflate_state FAR *state; local
1533 state = (struct inflate_state FAR *)strm->state;
1535 state->wrap |= 4;
1537 state->wrap &= ~4;
1544 struct inflate_state FAR *state; local
1548 state = (struct inflate_state FAR *)strm->state;
1549 return (long)(((unsigned long)((long)state->back)) << 16) +
1550 (state->mode == COPY ? state->length :
1551 (state->mode == MATCH ? state->was - state->length : 0));
1557 struct inflate_state FAR *state; local
1559 state = (struct inflate_state FAR *)strm->state;
1560 return (unsigned long)(state->next - state->codes);