Lines Matching refs:state
33 * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
37 * - Add comments on state->bits assertion in inffast.c
102 local void fixedtables OF((struct inflate_state FAR *state));
113 struct inflate_state FAR *state;
115 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
116 state = (struct inflate_state FAR *)strm->state;
117 strm->total_in = strm->total_out = state->total = 0;
120 state->mode = HEAD;
121 state->last = 0;
122 state->havedict = 0;
123 state->dmax = 32768U;
124 state->head = Z_NULL;
125 state->wsize = 0;
126 state->whave = 0;
127 state->write = 0;
128 state->hold = 0;
129 state->bits = 0;
130 state->lencode = state->distcode = state->next = state->codes;
140 struct inflate_state FAR *state;
142 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
143 state = (struct inflate_state FAR *)strm->state;
144 if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
146 state->hold += value << state->bits;
147 state->bits += bits;
157 struct inflate_state FAR *state;
169 state = (struct inflate_state FAR *)
171 if (state == Z_NULL) return Z_MEM_ERROR;
173 strm->state = (struct internal_state FAR *)state;
175 state->wrap = 0;
179 state->wrap = (windowBits >> 4) + 1;
185 ZFREE(strm, state);
186 strm->state = Z_NULL;
189 state->wbits = (unsigned)windowBits;
190 state->window = Z_NULL;
203 Return state with length and distance decoding tables and index sizes set to
212 local void fixedtables(state)
213 struct inflate_state FAR *state;
227 while (sym < 144) state->lens[sym++] = 8;
228 while (sym < 256) state->lens[sym++] = 9;
229 while (sym < 280) state->lens[sym++] = 7;
230 while (sym < 288) state->lens[sym++] = 8;
234 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
238 while (sym < 32) state->lens[sym++] = 5;
241 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
249 state->lencode = lenfix;
250 state->lenbits = 9;
251 state->distcode = distfix;
252 state->distbits = 5;
279 struct inflate_state state;
281 fixedtables(&state);
296 printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
297 state.lencode[low].val);
307 printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
308 state.distcode[low].val);
334 struct inflate_state FAR *state;
337 state = (struct inflate_state FAR *)strm->state;
340 if (state->window == Z_NULL) {
341 state->window = (unsigned char FAR *)
342 ZALLOC(strm, 1U << state->wbits,
344 if (state->window == Z_NULL) return 1;
348 if (state->wsize == 0) {
349 state->wsize = 1U << state->wbits;
350 state->write = 0;
351 state->whave = 0;
354 /* copy state->wsize or less output bytes into the circular window */
356 if (copy >= state->wsize) {
357 zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
358 state->write = 0;
359 state->whave = state->wsize;
362 dist = state->wsize - state->write;
364 zmemcpy(state->window + state->write, strm->next_out - copy, dist);
367 zmemcpy(state->window, strm->next_out - copy, copy);
368 state->write = copy;
369 state->whave = state->wsize;
372 state->write += dist;
373 if (state->write == state->wsize) state->write = 0;
374 if (state->whave < state->wsize) state->whave += dist;
385 (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
409 /* Load registers with state in inflate() for speed */
416 hold = state->hold; \
417 bits = state->bits; \
420 /* Restore state from registers in inflate() */
427 state->hold = hold; \
428 state->bits = bits; \
480 inflate() uses a state machine to process as much input data and generate as
481 much output data as possible before returning. The state machine is
484 for (;;) switch (state) {
490 state = STATEm;
497 next state. The NEEDBITS() macro is usually the way the state evaluates
520 state information is maintained to continue the loop where it left off
522 would all have to actually be part of the saved state in case NEEDBITS()
531 state = STATEx;
534 As shown above, if the next state is also the next case, then the break
537 A state may also return if there is not enough output space available to
538 complete that state. Those states are copying stored data, writing a
565 struct inflate_state FAR *state;
584 if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
588 state = (struct inflate_state FAR *)strm->state;
589 if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
595 switch (state->mode) {
597 if (state->wrap == 0) {
598 state->mode = TYPEDO;
603 if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
604 state->check = crc32(0L, Z_NULL, 0);
605 CRC2(state->check, hold);
607 state->mode = FLAGS;
610 state->flags = 0; /* expect zlib header */
611 if (state->head != Z_NULL)
612 state->head->done = -1;
613 if (!(state->wrap & 1) || /* check if zlib header allowed */
619 state->mode = BAD;
624 state->mode = BAD;
629 if (len > state->wbits) {
631 state->mode = BAD;
634 state->dmax = 1U << len;
636 strm->adler = state->check = adler32(0L, Z_NULL, 0);
637 state->mode = hold & 0x200 ? DICTID : TYPE;
643 state->flags = (int)(hold);
644 if ((state->flags & 0xff) != Z_DEFLATED) {
646 state->mode = BAD;
649 if (state->flags & 0xe000) {
651 state->mode = BAD;
654 if (state->head != Z_NULL)
655 state->head->text = (int)((hold >> 8) & 1);
656 if (state->flags & 0x0200) CRC2(state->check, hold);
658 state->mode = TIME;
662 if (state->head != Z_NULL)
663 state->head->time = hold;
664 if (state->flags & 0x0200) CRC4(state->check, hold);
666 state->mode = OS;
670 if (state->head != Z_NULL) {
671 state->head->xflags = (int)(hold & 0xff);
672 state->head->os = (int)(hold >> 8);
674 if (state->flags & 0x0200) CRC2(state->check, hold);
676 state->mode = EXLEN;
679 if (state->flags & 0x0400) {
681 state->length = (unsigned)(hold);
682 if (state->head != Z_NULL)
683 state->head->extra_len = (unsigned)hold;
684 if (state->flags & 0x0200) CRC2(state->check, hold);
687 else if (state->head != Z_NULL)
688 state->head->extra = Z_NULL;
689 state->mode = EXTRA;
692 if (state->flags & 0x0400) {
693 copy = state->length;
696 if (state->head != Z_NULL &&
697 state->head->extra != Z_NULL) {
698 len = state->head->extra_len - state->length;
699 zmemcpy(state->head->extra + len, next,
700 len + copy > state->head->extra_max ?
701 state->head->extra_max - len : copy);
703 if (state->flags & 0x0200)
704 state->check = crc32(state->check, next, copy);
707 state->length -= copy;
709 if (state->length) goto inf_leave;
711 state->length = 0;
712 state->mode = NAME;
715 if (state->flags & 0x0800) {
720 if (state->head != Z_NULL &&
721 state->head->name != Z_NULL &&
722 state->length < state->head->name_max)
723 state->head->name[state->length++] = len;
725 if (state->flags & 0x0200)
726 state->check = crc32(state->check, next, copy);
731 else if (state->head != Z_NULL)
732 state->head->name = Z_NULL;
733 state->length = 0;
734 state->mode = COMMENT;
737 if (state->flags & 0x1000) {
742 if (state->head != Z_NULL &&
743 state->head->comment != Z_NULL &&
744 state->length < state->head->comm_max)
745 state->head->comment[state->length++] = len;
747 if (state->flags & 0x0200)
748 state->check = crc32(state->check, next, copy);
753 else if (state->head != Z_NULL)
754 state->head->comment = Z_NULL;
755 state->mode = HCRC;
758 if (state->flags & 0x0200) {
760 if (hold != (state->check & 0xffff)) {
762 state->mode = BAD;
767 if (state->head != Z_NULL) {
768 state->head->hcrc = (int)((state->flags >> 9) & 1);
769 state->head->done = 1;
771 strm->adler = state->check = crc32(0L, Z_NULL, 0);
772 state->mode = TYPE;
777 strm->adler = state->check = REVERSE(hold);
779 state->mode = DICT;
782 if (state->havedict == 0) {
786 strm->adler = state->check = adler32(0L, Z_NULL, 0);
787 state->mode = TYPE;
793 if (state->last) {
795 state->mode = CHECK;
799 state->last = BITS(1);
804 state->last ? " (last)" : ""));
805 state->mode = STORED;
808 fixedtables(state);
810 state->last ? " (last)" : ""));
811 state->mode = LEN; /* decode codes */
815 state->last ? " (last)" : ""));
816 state->mode = TABLE;
820 state->mode = BAD;
829 state->mode = BAD;
832 state->length = (unsigned)hold & 0xffff;
834 state->length));
836 state->mode = COPY;
839 copy = state->length;
849 state->length -= copy;
853 state->mode = TYPE;
857 state->nlen = BITS(5) + 257;
859 state->ndist = BITS(5) + 1;
861 state->ncode = BITS(4) + 4;
864 if (state->nlen > 286 || state->ndist > 30) {
866 state->mode = BAD;
871 state->have = 0;
872 state->mode = LENLENS;
875 while (state->have < state->ncode) {
877 state->lens[order[state->have++]] = (unsigned short)BITS(3);
880 while (state->have < 19)
881 state->lens[order[state->have++]] = 0;
882 state->next = state->codes;
883 state->lencode = (code const FAR *)(state->next);
884 state->lenbits = 7;
885 ret = inflate_table(CODES, state->lens, 19, &(state->next),
886 &(state->lenbits), state->work);
889 state->mode = BAD;
893 state->have = 0;
894 state->mode = CODELENS;
897 while (state->have < state->nlen + state->ndist) {
899 this = state->lencode[BITS(state->lenbits)];
906 state->lens[state->have++] = this.val;
912 if (state->have == 0) {
914 state->mode = BAD;
917 len = state->lens[state->have - 1];
935 if (state->have + copy > state->nlen + state->ndist) {
937 state->mode = BAD;
941 state->lens[state->have++] = (unsigned short)len;
946 if (state->mode == BAD) break;
949 state->next = state->codes;
950 state->lencode = (code const FAR *)(state->next);
951 state->lenbits = 9;
952 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
953 &(state->lenbits), state->work);
956 state->mode = BAD;
959 state->distcode = (code const FAR *)(state->next);
960 state->distbits = 6;
961 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
962 &(state->next), &(state->distbits), state->work);
965 state->mode = BAD;
969 state->mode = LEN;
979 this = state->lencode[BITS(state->lenbits)];
986 this = state->lencode[last.val +
994 state->length = (unsigned)this.val;
999 state->mode = LIT;
1004 state->mode = TYPE;
1009 state->mode = BAD;
1012 state->extra = (unsigned)(this.op) & 15;
1013 state->mode = LENEXT;
1016 if (state->extra) {
1017 NEEDBITS(state->extra);
1018 state->length += BITS(state->extra);
1019 DROPBITS(state->extra);
1021 Tracevv((stderr, "inflate: length %u\n", state->length));
1022 state->mode = DIST;
1026 this = state->distcode[BITS(state->distbits)];
1033 this = state->distcode[last.val +
1043 state->mode = BAD;
1046 state->offset = (unsigned)this.val;
1047 state->extra = (unsigned)(this.op) & 15;
1048 state->mode = DISTEXT;
1051 if (state->extra) {
1052 NEEDBITS(state->extra);
1053 state->offset += BITS(state->extra);
1054 DROPBITS(state->extra);
1057 if (state->offset > state->dmax) {
1059 state->mode = BAD;
1063 if (state->offset > state->whave + out - left) {
1065 state->mode = BAD;
1068 Tracevv((stderr, "inflate: distance %u\n", state->offset));
1069 state->mode = MATCH;
1074 if (state->offset > copy) { /* copy from window */
1075 copy = state->offset - copy;
1076 if (copy > state->write) {
1077 copy -= state->write;
1078 from = state->window + (state->wsize - copy);
1081 from = state->window + (state->write - copy);
1082 if (copy > state->length) copy = state->length;
1085 from = put - state->offset;
1086 copy = state->length;
1090 state->length -= copy;
1094 if (state->length == 0) state->mode = LEN;
1098 *put++ = (unsigned char)(state->length);
1100 state->mode = LEN;
1103 if (state->wrap) {
1107 state->total += out;
1109 strm->adler = state->check =
1110 UPDATE(state->check, put - out, out);
1114 state->flags ? hold :
1116 REVERSE(hold)) != state->check) {
1118 state->mode = BAD;
1125 state->mode = LENGTH;
1128 if (state->wrap && state->flags) {
1130 if (hold != (state->total & 0xffffffffUL)) {
1132 state->mode = BAD;
1139 state->mode = DONE;
1157 error. Call updatewindow() to create and/or update the window state.
1162 if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
1164 state->mode = MEM;
1171 state->total += out;
1172 if (state->wrap && out)
1173 strm->adler = state->check =
1174 UPDATE(state->check, strm->next_out - out, out);
1175 strm->data_type = state->bits + (state->last ? 64 : 0) +
1176 (state->mode == TYPE ? 128 : 0);
1185 struct inflate_state FAR *state;
1186 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
1188 state = (struct inflate_state FAR *)strm->state;
1189 if (state->window != Z_NULL) ZFREE(strm, state->window);
1190 ZFREE(strm, strm->state);
1191 strm->state = Z_NULL;
1201 struct inflate_state FAR *state;
1204 /* check state */
1205 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1206 state = (struct inflate_state FAR *)strm->state;
1207 if (state->wrap != 0 && state->mode != DICT)
1211 if (state->mode == DICT) {
1214 if (id != state->check)
1220 state->mode = MEM;
1223 if (dictLength > state->wsize) {
1224 zmemcpy(state->window, dictionary + dictLength - state->wsize,
1225 state->wsize);
1226 state->whave = state->wsize;
1229 zmemcpy(state->window + state->wsize - dictLength, dictionary,
1231 state->whave = dictLength;
1233 state->havedict = 1;
1242 struct inflate_state FAR *state;
1244 /* check state */
1245 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1246 state = (struct inflate_state FAR *)strm->state;
1247 if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
1250 state->head = head;
1259 state. If on return *have equals four, then the pattern was found and the
1263 called again with more data and the *have state. *have is initialized to
1295 struct inflate_state FAR *state;
1298 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1299 state = (struct inflate_state FAR *)strm->state;
1300 if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
1303 if (state->mode != SYNC) {
1304 state->mode = SYNC;
1305 state->hold <<= state->bits & 7;
1306 state->bits -= state->bits & 7;
1308 while (state->bits >= 8) {
1309 buf[len++] = (unsigned char)(state->hold);
1310 state->hold >>= 8;
1311 state->bits -= 8;
1313 state->have = 0;
1314 (void) syncsearch(&(state->have), buf, len);
1318 len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
1324 if (state->have != 4) return Z_DATA_ERROR;
1328 state->mode = TYPE;
1343 struct inflate_state FAR *state;
1345 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
1346 state = (struct inflate_state FAR *)strm->state;
1347 return state->mode == STORED && state->bits == 0;
1354 struct inflate_state FAR *state;
1360 if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
1363 state = (struct inflate_state FAR *)source->state;
1370 if (state->window != Z_NULL) {
1372 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
1379 /* copy state */
1381 zmemcpy(copy, state, sizeof(struct inflate_state));
1382 if (state->lencode >= state->codes &&
1383 state->lencode <= state->codes + ENOUGH - 1) {
1384 copy->lencode = copy->codes + (state->lencode - state->codes);
1385 copy->distcode = copy->codes + (state->distcode - state->codes);
1387 copy->next = copy->codes + (state->next - state->codes);
1389 wsize = 1U << state->wbits;
1390 zmemcpy(window, state->window, wsize);
1393 dest->state = (struct internal_state FAR *)copy;