Lines Matching refs:state
26 * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
30 * - Add comments on state->bits assertion in inffast.c
96 local void fixedtables OF((struct inflate_state FAR *state));
108 struct inflate_state FAR *state;
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;
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;
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;
164 /* get the state */
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;
189 /* update state and reset the rest of it */
190 state->wrap = wrap;
191 state->wbits = (unsigned)windowBits;
202 struct inflate_state FAR *state;
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;
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;
269 Return state with length and distance decoding tables and index sizes set to
278 local void fixedtables(state)
279 struct inflate_state FAR *state;
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;
347 fixedtables(&state);
362 printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op,
363 state.lencode[low].bits, state.lencode[low].val);
373 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
374 state.distcode[low].val);
401 struct inflate_state FAR *state;
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;
421 /* copy state->wsize or less output bytes into the circular window */
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))
475 /* Load registers with state in inflate() for speed */
482 hold = state->hold; \
483 bits = state->bits; \
486 /* Restore state from registers in inflate() */
493 state->hold = hold; \
494 state->bits = bits; \
541 inflate() uses a state machine to process as much input data and generate as
542 much output data as possible before returning. The state machine is
545 for (;;) switch (state) {
551 state = STATEm;
558 next state. The NEEDBITS() macro is usually the way the state evaluates
581 state information is maintained to continue the loop where it left off
583 would all have to actually be part of the saved state in case NEEDBITS()
592 state = STATEx;
595 As shown above, if the next state is also the next case, then the break
598 A state may also return if there is not enough output space available to
599 complete that state. Those states are copying stored data, writing a
626 struct inflate_state FAR *state;
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;
1250 error. Call updatewindow() to create and/or update the window state.
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;
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;
1298 /* check state */
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;
1323 /* check state */
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;
1355 /* check state */
1357 state = (struct inflate_state FAR *)strm->state;
1358 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1361 state->head = head;
1370 state. If on return *have equals four, then the pattern was found and the
1374 called again with more data and the *have state. *have is initialized to
1406 struct inflate_state FAR *state;
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;
1457 state = (struct inflate_state FAR *)strm->state;
1458 return state->mode == STORED && state->bits == 0;
1465 struct inflate_state FAR *state;
1473 state = (struct inflate_state FAR *)source->state;
1480 if (state->window != Z_NULL) {
1482 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1489 /* copy state */
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;
1515 state = (struct inflate_state FAR *)strm->state;
1517 state->sane = !subvert;
1521 state->sane = 1;
1530 struct inflate_state FAR *state;
1533 state = (struct inflate_state FAR *)strm->state;
1535 state->wrap |= 4;
1537 state->wrap &= ~4;
1544 struct inflate_state FAR *state;
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;
1559 state = (struct inflate_state FAR *)strm->state;
1560 return (unsigned long)(state->next - state->codes);