Lines Matching full:state
26 * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
30 * - Add comments on state->bits assertion in inffast.c
95 local void fixedtables OF((struct inflate_state FAR *state));
106 struct inflate_state FAR *state;
108 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
109 state = (struct inflate_state FAR *)strm->state;
110 strm->total_in = strm->total_out = state->total = 0;
112 if (state->wrap) /* to support ill-conceived Java test suite */
113 strm->adler = state->wrap & 1;
114 state->mode = HEAD;
115 state->last = 0;
116 state->havedict = 0;
117 state->dmax = 32768U;
118 state->head = Z_NULL;
119 state->hold = 0;
120 state->bits = 0;
121 state->lencode = state->distcode = state->next = state->codes;
122 state->sane = 1;
123 state->back = -1;
131 struct inflate_state FAR *state;
133 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
134 state = (struct inflate_state FAR *)strm->state;
135 state->wsize = 0;
136 state->whave = 0;
137 state->wnext = 0;
146 struct inflate_state FAR *state;
148 /* get the state */
149 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
150 state = (struct inflate_state FAR *)strm->state;
168 if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
169 ZFREE(strm, state->window);
170 state->window = Z_NULL;
173 /* update state and reset the rest of it */
174 state->wrap = wrap;
175 state->wbits = (unsigned)windowBits;
186 struct inflate_state FAR *state;
207 state = (struct inflate_state FAR *)
209 if (state == Z_NULL) return Z_MEM_ERROR;
211 strm->state = (struct internal_state FAR *)state;
212 state->window = Z_NULL;
215 ZFREE(strm, state);
216 strm->state = Z_NULL;
234 struct inflate_state FAR *state;
236 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
237 state = (struct inflate_state FAR *)strm->state;
239 state->hold = 0;
240 state->bits = 0;
243 if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
245 state->hold += value << state->bits;
246 state->bits += bits;
251 Return state with length and distance decoding tables and index sizes set to
260 local void fixedtables(state)
261 struct inflate_state FAR *state;
275 while (sym < 144) state->lens[sym++] = 8;
276 while (sym < 256) state->lens[sym++] = 9;
277 while (sym < 280) state->lens[sym++] = 7;
278 while (sym < 288) state->lens[sym++] = 8;
282 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
286 while (sym < 32) state->lens[sym++] = 5;
289 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
297 state->lencode = lenfix;
298 state->lenbits = 9;
299 state->distcode = distfix;
300 state->distbits = 5;
327 struct inflate_state state;
329 fixedtables(&state);
344 printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op,
345 state.lencode[low].bits, state.lencode[low].val);
355 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
356 state.distcode[low].val);
382 struct inflate_state FAR *state;
385 state = (struct inflate_state FAR *)strm->state;
388 if (state->window == Z_NULL) {
389 state->window = (unsigned char FAR *)
390 ZALLOC(strm, 1U << state->wbits,
392 if (state->window == Z_NULL) return 1;
396 if (state->wsize == 0) {
397 state->wsize = 1U << state->wbits;
398 state->wnext = 0;
399 state->whave = 0;
402 /* copy state->wsize or less output bytes into the circular window */
404 if (copy >= state->wsize) {
405 zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
406 state->wnext = 0;
407 state->whave = state->wsize;
410 dist = state->wsize - state->wnext;
412 zmemcpy(state->window + state->wnext, strm->next_out - copy, dist);
415 zmemcpy(state->window, strm->next_out - copy, copy);
416 state->wnext = copy;
417 state->whave = state->wsize;
420 state->wnext += dist;
421 if (state->wnext == state->wsize) state->wnext = 0;
422 if (state->whave < state->wsize) state->whave += dist;
433 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
457 /* Load registers with state in inflate() for speed */
464 hold = state->hold; \
465 bits = state->bits; \
468 /* Restore state from registers in inflate() */
475 state->hold = hold; \
476 state->bits = bits; \
523 inflate() uses a state machine to process as much input data and generate as
524 much output data as possible before returning. The state machine is
527 for (;;) switch (state) {
533 state = STATEm;
540 next state. The NEEDBITS() macro is usually the way the state evaluates
563 state information is maintained to continue the loop where it left off
565 would all have to actually be part of the saved state in case NEEDBITS()
574 state = STATEx;
577 As shown above, if the next state is also the next case, then the break
580 A state may also return if there is not enough output space available to
581 complete that state. Those states are copying stored data, writing a
608 struct inflate_state FAR *state;
627 if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
631 state = (struct inflate_state FAR *)strm->state;
632 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
638 switch (state->mode) {
640 if (state->wrap == 0) {
641 state->mode = TYPEDO;
646 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
647 state->check = crc32(0L, Z_NULL, 0);
648 CRC2(state->check, hold);
650 state->mode = FLAGS;
653 state->flags = 0; /* expect zlib header */
654 if (state->head != Z_NULL)
655 state->head->done = -1;
656 if (!(state->wrap & 1) || /* check if zlib header allowed */
662 state->mode = BAD;
667 state->mode = BAD;
672 if (state->wbits == 0)
673 state->wbits = len;
674 else if (len > state->wbits) {
676 state->mode = BAD;
679 state->dmax = 1U << len;
681 strm->adler = state->check = adler32(0L, Z_NULL, 0);
682 state->mode = hold & 0x200 ? DICTID : TYPE;
688 state->flags = (int)(hold);
689 if ((state->flags & 0xff) != Z_DEFLATED) {
691 state->mode = BAD;
694 if (state->flags & 0xe000) {
696 state->mode = BAD;
699 if (state->head != Z_NULL)
700 state->head->text = (int)((hold >> 8) & 1);
701 if (state->flags & 0x0200) CRC2(state->check, hold);
703 state->mode = TIME;
706 if (state->head != Z_NULL)
707 state->head->time = hold;
708 if (state->flags & 0x0200) CRC4(state->check, hold);
710 state->mode = OS;
713 if (state->head != Z_NULL) {
714 state->head->xflags = (int)(hold & 0xff);
715 state->head->os = (int)(hold >> 8);
717 if (state->flags & 0x0200) CRC2(state->check, hold);
719 state->mode = EXLEN;
721 if (state->flags & 0x0400) {
723 state->length = (unsigned)(hold);
724 if (state->head != Z_NULL)
725 state->head->extra_len = (unsigned)hold;
726 if (state->flags & 0x0200) CRC2(state->check, hold);
729 else if (state->head != Z_NULL)
730 state->head->extra = Z_NULL;
731 state->mode = EXTRA;
733 if (state->flags & 0x0400) {
734 copy = state->length;
737 if (state->head != Z_NULL &&
738 state->head->extra != Z_NULL) {
739 len = state->head->extra_len - state->length;
740 zmemcpy(state->head->extra + len, next,
741 len + copy > state->head->extra_max ?
742 state->head->extra_max - len : copy);
744 if (state->flags & 0x0200)
745 state->check = crc32(state->check, next, copy);
748 state->length -= copy;
750 if (state->length) goto inf_leave;
752 state->length = 0;
753 state->mode = NAME;
755 if (state->flags & 0x0800) {
760 if (state->head != Z_NULL &&
761 state->head->name != Z_NULL &&
762 state->length < state->head->name_max)
763 state->head->name[state->length++] = len;
765 if (state->flags & 0x0200)
766 state->check = crc32(state->check, next, copy);
771 else if (state->head != Z_NULL)
772 state->head->name = Z_NULL;
773 state->length = 0;
774 state->mode = COMMENT;
776 if (state->flags & 0x1000) {
781 if (state->head != Z_NULL &&
782 state->head->comment != Z_NULL &&
783 state->length < state->head->comm_max)
784 state->head->comment[state->length++] = len;
786 if (state->flags & 0x0200)
787 state->check = crc32(state->check, next, copy);
792 else if (state->head != Z_NULL)
793 state->head->comment = Z_NULL;
794 state->mode = HCRC;
796 if (state->flags & 0x0200) {
798 if (hold != (state->check & 0xffff)) {
800 state->mode = BAD;
805 if (state->head != Z_NULL) {
806 state->head->hcrc = (int)((state->flags >> 9) & 1);
807 state->head->done = 1;
809 strm->adler = state->check = crc32(0L, Z_NULL, 0);
810 state->mode = TYPE;
815 strm->adler = state->check = ZSWAP32(hold);
817 state->mode = DICT;
819 if (state->havedict == 0) {
823 strm->adler = state->check = adler32(0L, Z_NULL, 0);
824 state->mode = TYPE;
828 if (state->last) {
830 state->mode = CHECK;
834 state->last = BITS(1);
839 state->last ? " (last)" : ""));
840 state->mode = STORED;
843 fixedtables(state);
845 state->last ? " (last)" : ""));
846 state->mode = LEN_; /* decode codes */
854 state->last ? " (last)" : ""));
855 state->mode = TABLE;
859 state->mode = BAD;
868 state->mode = BAD;
871 state->length = (unsigned)hold & 0xffff;
873 state->length));
875 state->mode = COPY_;
878 state->mode = COPY;
880 copy = state->length;
890 state->length -= copy;
894 state->mode = TYPE;
898 state->nlen = BITS(5) + 257;
900 state->ndist = BITS(5) + 1;
902 state->ncode = BITS(4) + 4;
905 if (state->nlen > 286 || state->ndist > 30) {
907 state->mode = BAD;
912 state->have = 0;
913 state->mode = LENLENS;
915 while (state->have < state->ncode) {
917 state->lens[order[state->have++]] = (unsigned short)BITS(3);
920 while (state->have < 19)
921 state->lens[order[state->have++]] = 0;
922 state->next = state
923 state->lencode = (code const FAR *)(state->next);
924 state->lenbits = 7;
925 ret = inflate_table(CODES, state->lens, 19, &(state->next),
926 &(state->lenbits), state->work);
929 state->mode = BAD;
933 state->have = 0;
934 state->mode = CODELENS;
936 while (state->have < state->nlen + state->ndist) {
938 here = state->lencode[BITS(state->lenbits)];
944 state->lens[state->have++] = here.val;
950 if (state->have == 0) {
952 state->mode = BAD;
955 len = state->lens[state->have - 1];
973 if (state->have + copy > state->nlen + state->ndist) {
975 state->mode = BAD;
979 state->lens[state->have++] = (unsigned short)len;
984 if (state->mode == BAD) break;
987 if (state->lens[256] == 0) {
989 state->mode = BAD;
996 state->next = state->codes;
997 state->lencode = (code const FAR *)(state->next);
998 state->lenbits = 9;
999 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
1000 &(state->lenbits), state->work);
1003 state->mode = BAD;
1006 state->distcode = (code const FAR *)(state->next);
1007 state->distbits = 6;
1008 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
1009 &(state->next), &(state->distbits), state->work);
1012 state->mode = BAD;
1016 state->mode = LEN_;
1019 state->mode = LEN;
1025 if (state->mode == TYPE)
1026 state->back = -1;
1029 state->back = 0;
1031 here = state->lencode[BITS(state->lenbits)];
1038 here = state->lencode[last.val +
1044 state->back += last.bits;
1047 state->back += here.bits;
1048 state->length = (unsigned)here.val;
1053 state->mode = LIT;
1058 state->back = -1;
1059 state->mode = TYPE;
1064 state->mode = BAD;
1067 state->extra = (unsigned)(here.op) & 15;
1068 state->mode = LENEXT;
1070 if (state->extra) {
1071 NEEDBITS(state->extra);
1072 state->length += BITS(state->extra);
1073 DROPBITS(state->extra);
1074 state->back += state->extra;
1076 Tracevv((stderr, "inflate: length %u\n", state->length));
1077 state->was = state->length;
1078 state->mode = DIST;
1081 here = state->distcode[BITS(state->distbits)];
1088 here = state->distcode[last.val +
1094 state->back += last.bits;
1097 state->back += here.bits;
1100 state->mode = BAD;
1103 state->offset = (unsigned)here.val;
1104 state->extra = (unsigned)(here.op) & 15;
1105 state->mode = DISTEXT;
1107 if (state->extra) {
1108 NEEDBITS(state->extra);
1109 state->offset += BITS(state->extra);
1110 DROPBITS(state->extra);
1111 state->back += state->extra;
1114 if (state->offset > state->dmax) {
1116 state->mode = BAD;
1120 Tracevv((stderr, "inflate: distance %u\n", state->offset));
1121 state->mode = MATCH;
1125 if (state->offset > copy) { /* copy from window */
1126 copy = state->offset - copy;
1127 if (copy > state->whave) {
1128 if (state->sane) {
1130 state->mode = BAD;
1135 copy -= state->whave;
1136 if (copy > state->length) copy = state->length;
1139 state->length -= copy;
1143 if (state->length == 0) state->mode = LEN;
1147 if (copy > state->wnext) {
1148 copy -= state->wnext;
1149 from = state->window + (state->wsize - copy);
1152 from = state->window + (state->wnext - copy);
1153 if (copy > state->length) copy = state->length;
1156 from = put - state->offset;
1157 copy = state->length;
1161 state->length -= copy;
1165 if (state->length == 0) state->mode = LEN;
1169 *put++ = (unsigned char)(state->length);
1171 state->mode = LEN;
1174 if (state->wrap) {
1178 state->total += out;
1180 strm->adler = state->check =
1181 UPDATE(state->check, put - out, out);
1185 state->flags ? hold :
1187 ZSWAP32(hold)) != state->check) {
1189 state->mode = BAD;
1196 state->mode = LENGTH;
1198 if (state->wrap && state->flags) {
1200 if (hold != (state->total & 0xffffffffUL)) {
1202 state->mode = BAD;
1209 state->mode = DONE;
1226 error. Call updatewindow() to create and/or update the window state.
1231 if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
1232 (state->mode < CHECK || flush != Z_FINISH)))
1234 state->mode = MEM;
1241 state->total += out;
1242 if (state->wrap && out)
1243 strm->adler = state->check =
1244 UPDATE(state->check, strm->next_out - out, out);
1245 strm->data_type = state->bits + (state->last ? 64 : 0) +
1246 (state->mode == TYPE ? 128 : 0) +
1247 (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
1256 struct inflate_state FAR *state;
1257 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1259 state = (struct inflate_state FAR *)strm->state;
1260 if (state->window != Z_NULL) ZFREE(strm, state->window);
1261 ZFREE(strm, strm->state);
1262 strm->state = Z_NULL;
1272 struct inflate_state FAR *state;
1278 /* check state */
1279 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1280 state = (struct inflate_state FAR *)strm->state;
1281 if (state->wrap != 0 && state->mode != DICT)
1285 if (state->mode == DICT) {
1288 if (dictid != state->check)
1302 state->mode = MEM;
1305 state->havedict = 1;
1314 struct inflate_state FAR *state;
1316 /* check state */
1317 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1318 state = (struct inflate_state FAR *)strm->state;
1319 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1322 state->head = head;
1331 state. If on return *have equals four, then the pattern was found and the
1335 called again with more data and the *have state. *have is initialized to
1367 struct inflate_state FAR *state;
1370 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1371 state = (struct inflate_state FAR *)strm->state;
1372 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1375 if (state->mode != SYNC) {
1376 state
1377 state->hold <<= state->bits & 7;
1378 state->bits -= state->bits & 7;
1380 while (state->bits >= 8) {
1381 buf[len++] = (unsigned char)(state->hold);
1382 state->hold >>= 8;
1383 state->bits -= 8;
1385 state->have = 0;
1386 syncsearch(&(state->have), buf, len);
1390 len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1396 if (state->have != 4) return Z_DATA_ERROR;
1400 state->mode = TYPE;
1415 struct inflate_state FAR *state;
1417 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1418 state = (struct inflate_state FAR *)strm->state;
1419 return state->mode == STORED && state->bits == 0;
1426 struct inflate_state FAR *state;
1432 if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1435 state = (struct inflate_state FAR *)source->state;
1442 if (state->window != Z_NULL) {
1444 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1451 /* copy state */
1453 zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
1454 if (state->lencode >= state->codes &&
1455 state->lencode <= state->codes + ENOUGH - 1) {
1456 copy->lencode = copy->codes + (state->lencode - state->codes);
1457 copy->distcode = copy->codes + (state->distcode - state->codes);
1459 copy->next = copy->codes + (state->next - state->codes);
1461 wsize = 1U << state->wbits;
1462 zmemcpy(window, state->window, wsize);
1465 dest->state = (struct internal_state FAR *)copy;
1473 struct inflate_state FAR *state;
1475 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1476 state = (struct inflate_state FAR *)strm->state;
1477 state->sane = !subvert;
1481 state->sane = 1;
1489 struct inflate_state FAR *state;
1491 if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
1492 state = (struct inflate_state FAR *)strm->state;
1493 return ((long)(state->back) << 16) +
1494 (state->mode == COPY ? state->length :
1495 (state->mode == MATCH ? state->was - state->length : 0));
