Lines Matching refs:state

4069   var s = strm.state;
4131 if (strm.state.wrap === 1) {
4135 else if (strm.state.wrap === 2) {
5208 if (!strm || !strm.state) {
5215 s = strm.state;
5237 lm_init(strm.state);
5244 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
5245 if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; }
5246 strm.state.gzhead = head;
5286 strm.state = s;
5331 if (!strm || !strm.state ||
5336 s = strm.state;
5664 if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) {
5668 status = strm.state.status;
5680 strm.state = null;
5794 var state;
5825 state = strm.state;
5835 dmax = state.dmax;
5837 wsize = state.wsize;
5838 whave = state.whave;
5839 wnext = state.wnext;
5840 window = state.window;
5841 hold = state.hold;
5842 bits = state.bits;
5843 lcode = state.lencode;
5844 dcode = state.distcode;
5845 lmask = (1 << state.lenbits) - 1;
5846 dmask = (1 << state.distbits) - 1;
5918 state.mode = BAD;
5929 if (state.sane) {
5931 state.mode = BAD;
6036 state.mode = BAD;
6049 state.mode = TYPE;
6054 state.mode = BAD;
6073 state.hold = hold;
6074 state.bits = bits;
6240 var state;
6242 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
6243 state = strm.state;
6244 strm.total_in = strm.total_out = state.total = 0;
6246 if (state.wrap) { /* to support ill-conceived Java test suite */
6247 strm.adler = state.wrap & 1;
6249 state.mode = HEAD;
6250 state.last = 0;
6251 state.havedict = 0;
6252 state.dmax = 32768;
6253 state.head = null/*Z_NULL*/;
6254 state.hold = 0;
6255 state.bits = 0;
6257 state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
6258 state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
6260 state.sane = 1;
6261 state.back = -1;
6267 var state;
6269 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
6270 state = strm.state;
6271 state.wsize = 0;
6272 state.whave = 0;
6273 state.wnext = 0;
6280 var state;
6283 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
6284 state = strm.state;
6302 if (state.window !== null && state.wbits !== windowBits) {
6303 state.window = null;
6307 state.wrap = wrap;
6308 state.wbits = windowBits;
6314 var state;
6319 state = new InflateState();
6323 strm.state = state;
6324 state.window = null/*Z_NULL*/;
6327 strm.state = null/*Z_NULL*/;
6351 function fixedtables(state) { argument
6361 while (sym < 144) { state.lens[sym++] = 8; }
6362 while (sym < 256) { state.lens[sym++] = 9; }
6363 while (sym < 280) { state.lens[sym++] = 7; }
6364 while (sym < 288) { state.lens[sym++] = 8; }
6366 inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, {bits: 9});
6370 while (sym < 32) { state.lens[sym++] = 5; }
6372 inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, {bits: 5});
6378 state.lencode = lenfix;
6379 state.lenbits = 9;
6380 state.distcode = distfix;
6381 state.distbits = 5;
6401 var state = strm.state;
6404 if (state.window === null) {
6405 state.wsize = 1 << state.wbits;
6406 state.wnext = 0;
6407 state.whave = 0;
6409 state.window = new utils.Buf8(state.wsize);
6413 if (copy >= state.wsize) {
6414 utils.arraySet(state.window,src, end - state.wsize, state.wsize, 0);
6415 state.wnext = 0;
6416 state.whave = state.wsize;
6419 dist = state.wsize - state.wnext;
6424 utils.arraySet(state.window,src, end - copy, dist, state.wnext);
6428 utils.arraySet(state.window,src, end - copy, copy, 0);
6429 state.wnext = copy;
6430 state.whave = state.wsize;
6433 state.wnext += dist;
6434 if (state.wnext === state.wsize) { state.wnext = 0; }
6435 if (state.whave < state.wsize) { state.whave += dist; }
6442 var state;
6468 if (!strm || !strm.state || !strm.output ||
6473 state = strm.state;
6474 if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */
6484 hold = state.hold;
6485 bits = state.bits;
6494 switch (state.mode) {
6496 if (state.wrap === 0) {
6497 state.mode = TYPEDO;
6508 if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */
6509 state.check = 0/*crc32(0L, Z_NULL, 0)*/;
6513 state.check = crc32(state.check, hbuf, 2, 0);
6520 state.mode = FLAGS;
6523 state.flags = 0; /* expect zlib header */
6524 if (state.head) {
6525 state.head.done = false;
6527 if (!(state.wrap & 1) || /* check if zlib header allowed */
6530 state.mode = BAD;
6535 state.mode = BAD;
6543 if (state.wbits === 0) {
6544 state.wbits = len;
6546 else if (len > state.wbits) {
6548 state.mode = BAD;
6551 state.dmax = 1 << len;
6553 strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
6554 state.mode = hold & 0x200 ? DICTID : TYPE;
6569 state.flags = hold;
6570 if ((state.flags & 0xff) !== Z_DEFLATED) {
6572 state.mode = BAD;
6575 if (state.flags & 0xe000) {
6577 state.mode = BAD;
6580 if (state.head) {
6581 state.head.text = ((hold >> 8) & 1);
6583 if (state.flags & 0x0200) {
6587 state.check = crc32(state.check, hbuf, 2, 0);
6594 state.mode = TIME;
6605 if (state.head) {
6606 state.head.time = hold;
6608 if (state.flags & 0x0200) {
6614 state.check = crc32(state.check, hbuf, 4, 0);
6621 state.mode = OS;
6632 if (state.head) {
6633 state.head.xflags = (hold & 0xff);
6634 state.head.os = (hold >> 8);
6636 if (state.flags & 0x0200) {
6640 state.check = crc32(state.check, hbuf, 2, 0);
6647 state.mode = EXLEN;
6650 if (state.flags & 0x0400) {
6659 state.length = hold;
6660 if (state.head) {
6661 state.head.extra_len = hold;
6663 if (state.flags & 0x0200) {
6667 state.check = crc32(state.check, hbuf, 2, 0);
6675 else if (state.head) {
6676 state.head.extra = null/*Z_NULL*/;
6678 state.mode = EXTRA;
6681 if (state.flags & 0x0400) {
6682 copy = state.length;
6685 if (state.head) {
6686 len = state.head.extra_len - state.length;
6687 if (!state.head.extra) {
6689 state.head.extra = new Array(state.head.extra_len);
6692 state.head.extra,
6705 if (state.flags & 0x0200) {
6706 state.check = crc32(state.check, input, copy, next);
6710 state.length -= copy;
6712 if (state.length) { break inf_leave; }
6714 state.length = 0;
6715 state.mode = NAME;
6718 if (state.flags & 0x0800) {
6725 if (state.head && len &&
6726 (state.length < 65536 /*state.head.name_max*/)) {
6727 state.head.name += String.fromCharCode(len);
6731 if (state.flags & 0x0200) {
6732 state.check = crc32(state.check, input, copy, next);
6738 else if (state.head) {
6739 state.head.name = null;
6741 state.length = 0;
6742 state.mode = COMMENT;
6745 if (state.flags & 0x1000) {
6751 if (state.head && len &&
6752 (state.length < 65536 /*state.head.comm_max*/)) {
6753 state.head.comment += String.fromCharCode(len);
6756 if (state.flags & 0x0200) {
6757 state.check = crc32(state.check, input, copy, next);
6763 else if (state.head) {
6764 state.head.comment = null;
6766 state.mode = HCRC;
6769 if (state.flags & 0x0200) {
6778 if (hold !== (state.check & 0xffff)) {
6780 state.mode = BAD;
6788 if (state.head) {
6789 state.head.hcrc = ((state.flags >> 9) & 1);
6790 state.head.done = true;
6792 strm.adler = state.check = 0 /*crc32(0L, Z_NULL, 0)*/;
6793 state.mode = TYPE;
6804 strm.adler = state.check = ZSWAP32(hold);
6809 state.mode = DICT;
6812 if (state.havedict === 0) {
6818 state.hold = hold;
6819 state.bits = bits;
6823 strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
6824 state.mode = TYPE;
6830 if (state.last) {
6835 state.mode = CHECK;
6846 state.last = (hold & 0x01)/*BITS(1)*/;
6856 state.mode = STORED;
6859 fixedtables(state);
6862 state.mode = LEN_; /* decode codes */
6874 state.mode = TABLE;
6878 state.mode = BAD;
6900 state.mode = BAD;
6903 state.length = hold & 0xffff;
6910 state.mode = COPY_;
6914 state.mode = COPY;
6917 copy = state.length;
6929 state.length -= copy;
6933 state.mode = TYPE;
6944 state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;
6949 state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;
6954 state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;
6960 if (state.nlen > 286 || state.ndist > 30) {
6962 state.mode = BAD;
6967 state.have = 0;
6968 state.mode = LENLENS;
6971 while (state.have < state.ncode) {
6980 state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);
6986 while (state.have < 19) {
6987 state.lens[order[state.have++]] = 0;
6993 state.lencode = state.lendyn;
6994 state.lenbits = 7;
6996 opts = {bits: state.lenbits};
6997 ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
6998 state.lenbits = opts.bits;
7002 state.mode = BAD;
7006 state.have = 0;
7007 state.mode = CODELENS;
7010 while (state.have < state.nlen + state.ndist) {
7012 here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/
7030 state.lens[state.have++] = here_val;
7047 if (state.have === 0) {
7049 state.mode = BAD;
7052 len = state.lens[state.have - 1];
7101 if (state.have + copy > state.nlen + state.ndist) {
7103 state.mode = BAD;
7107 state.lens[state.have++] = len;
7113 if (state.mode === BAD) { break; }
7116 if (state.lens[256] === 0) {
7118 state.mode = BAD;
7125 state.lenbits = 9;
7127 opts = {bits: state.lenbits};
7128 ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
7131 state.lenbits = opts.bits;
7136 state.mode = BAD;
7140 state.distbits = 6;
7143 state.distcode = state.distdyn;
7144 opts = {bits: state.distbits};
7145 …ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opt…
7148 state.distbits = opts.bits;
7153 state.mode = BAD;
7157 state.mode = LEN_;
7161 state.mode = LEN;
7170 state.hold = hold;
7171 state.bits = bits;
7181 hold = state.hold;
7182 bits = state.bits;
7185 if (state.mode === TYPE) {
7186 state.back = -1;
7190 state.back = 0;
7192 here = state.lencode[hold & ((1 << state.lenbits) -1)]; /*BITS(state.lenbits)*/
7210 here = state.lencode[last_val +
7228 state.back += last_bits;
7234 state.back += here_bits;
7235 state.length = here_val;
7240 state.mode = LIT;
7245 state.back = -1;
7246 state.mode = TYPE;
7251 state.mode = BAD;
7254 state.extra = here_op & 15;
7255 state.mode = LENEXT;
7258 if (state.extra) {
7260 n = state.extra;
7268 state.length += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/;
7270 hold >>>= state.extra;
7271 bits -= state.extra;
7273 state.back += state.extra;
7276 state.was = state.length;
7277 state.mode = DIST;
7281 here = state.distcode[hold & ((1 << state.distbits) -1)];/*BITS(state.distbits)*/
7299 here = state.distcode[last_val +
7317 state.back += last_bits;
7323 state.back += here_bits;
7326 state.mode = BAD;
7329 state.offset = here_val;
7330 state.extra = (here_op) & 15;
7331 state.mode = DISTEXT;
7334 if (state.extra) {
7336 n = state.extra;
7344 state.offset += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/;
7346 hold >>>= state.extra;
7347 bits -= state.extra;
7349 state.back += state.extra;
7352 if (state.offset > state.dmax) {
7354 state.mode = BAD;
7359 state.mode = MATCH;
7364 if (state.offset > copy) { /* copy from window */
7365 copy = state.offset - copy;
7366 if (copy > state.whave) {
7367 if (state.sane) {
7369 state.mode = BAD;
7388 if (copy > state.wnext) {
7389 copy -= state.wnext;
7390 from = state.wsize - copy;
7393 from = state.wnext - copy;
7395 if (copy > state.length) { copy = state.length; }
7396 from_source = state.window;
7400 from = put - state.offset;
7401 copy = state.length;
7405 state.length -= copy;
7409 if (state.length === 0) { state.mode = LEN; }
7413 output[put++] = state.length;
7415 state.mode = LEN;
7418 if (state.wrap) {
7430 state.total += _out;
7432 strm.adler = state.check =
7434 …(state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, p…
7439 if ((state.flags ? hold : ZSWAP32(hold)) !== state.check) {
7441 state.mode = BAD;
7450 state.mode = LENGTH;
7453 if (state.wrap && state.flags) {
7462 if (hold !== (state.total & 0xffffffff)) {
7464 state.mode = BAD;
7473 state.mode = DONE;
7504 state.hold = hold;
7505 state.bits = bits;
7508 if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
7509 (state.mode < CHECK || flush !== Z_FINISH))) {
7511 state.mode = MEM;
7519 state.total += _out;
7520 if (state.wrap && _out) {
7521 strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
7522 …(state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, outpu…
7524 strm.data_type = state.bits + (state.last ? 64 : 0) +
7525 (state.mode === TYPE ? 128 : 0) +
7526 (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
7535 if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
7539 var state = strm.state;
7540 if (state.window) {
7541 state.window = null;
7543 strm.state = null;
7548 var state;
7551 if (!strm || !strm.state) { return Z_STREAM_ERROR; }
7552 state = strm.state;
7553 if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }
7556 state.head = head;
9145 this.state = null;