mirror of
https://github.com/0x5eal/rbxts-pako.git
synced 2025-04-04 10:50:59 +01:00
Removed local closures from inflate()
This commit is contained in:
Vitaly Puzrin
parent
8a6a0f004c
commit
1079e6d9eb
1 changed files with 127 additions and 100 deletions
|
|
@ -91,6 +91,15 @@ var MAX_WBITS = 15;
|
|||
/* 32K LZ77 window */
|
||||
var DEF_WBITS = MAX_WBITS;
|
||||
|
||||
|
||||
function ZSWAP32(q) {
|
||||
return (((q >>> 24) & 0xff) +
|
||||
((q >>> 8) & 0xff00) +
|
||||
((q & 0xff00) << 8) +
|
||||
((q & 0xff) << 24));
|
||||
}
|
||||
|
||||
|
||||
function Code() {
|
||||
this.op = 0; /* operation, extra bits, table bits */
|
||||
this.bits = 0; /* bits in this part of the code */
|
||||
|
|
@ -482,65 +491,6 @@ function inflate(strm, flush) {
|
|||
var order = /* permutation of code lengths */
|
||||
[16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
|
||||
|
||||
function LOAD() {
|
||||
put = strm.next_out_index;
|
||||
output = strm.next_out;
|
||||
left = strm.avail_out;
|
||||
next = strm.next_in_index;
|
||||
input = strm.next_in;
|
||||
have = strm.avail_in;
|
||||
hold = state.hold;
|
||||
bits = state.bits;
|
||||
}
|
||||
|
||||
function RESTORE() {
|
||||
strm.next_out_index = put;
|
||||
strm.avail_out = left;
|
||||
strm.next_in_index = next;
|
||||
strm.avail_in = have;
|
||||
state.hold = hold;
|
||||
state.bits = bits;
|
||||
}
|
||||
|
||||
function ZSWAP32(q) {
|
||||
return (((q >>> 24) & 0xff) +
|
||||
((q >>> 8) & 0xff00) +
|
||||
((q & 0xff00) << 8) +
|
||||
((q & 0xff) << 24));
|
||||
}
|
||||
|
||||
/*
|
||||
Return from inflate(), updating the total counts and the check value.
|
||||
If there was no progress during the inflate() call, return a buffer
|
||||
error. Call updatewindow() to create and/or update the window state.
|
||||
Note: a memory error from inflate() is non-recoverable.
|
||||
*/
|
||||
function inf_leave() {
|
||||
RESTORE();
|
||||
if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
|
||||
(state.mode < CHECK || flush !== Z_FINISH))) {
|
||||
if (updatewindow(strm, strm.next_out, strm.next_out_index, _out - strm.avail_out)) {
|
||||
state.mode = MEM;
|
||||
return Z_MEM_ERROR;
|
||||
}
|
||||
}
|
||||
_in -= strm.avail_in;
|
||||
_out -= strm.avail_out;
|
||||
strm.total_in += _in;
|
||||
strm.total_out += _out;
|
||||
state.total += _out;
|
||||
if (state.wrap && _out) {
|
||||
strm.adler = state.check = /*UPDATE(state.check, strm.next_out_index - _out, _out);*/
|
||||
(state.flags ? crc32(state.check, output, _out, strm.next_out_index - _out) : adler32(state.check, output, _out, strm.next_out_index - _out));
|
||||
}
|
||||
strm.data_type = state.bits + (state.last ? 64 : 0) +
|
||||
(state.mode === TYPE ? 128 : 0) +
|
||||
(state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
|
||||
if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {
|
||||
ret = Z_BUF_ERROR;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
// TODO: check if needed and don't affect speed
|
||||
//if (strm === Z_NULL || strm.state === Z_NULL || strm.next_out === Z_NULL ||
|
||||
|
|
@ -551,11 +501,22 @@ function inflate(strm, flush) {
|
|||
if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */
|
||||
|
||||
|
||||
LOAD();
|
||||
//--- LOAD() ---
|
||||
put = strm.next_out_index;
|
||||
output = strm.next_out;
|
||||
left = strm.avail_out;
|
||||
next = strm.next_in_index;
|
||||
input = strm.next_in;
|
||||
have = strm.avail_in;
|
||||
hold = state.hold;
|
||||
bits = state.bits;
|
||||
//---
|
||||
|
||||
_in = have;
|
||||
_out = left;
|
||||
ret = Z_OK;
|
||||
|
||||
inf_leave: // goto emulation
|
||||
for (;;) {
|
||||
switch (state.mode) {
|
||||
case HEAD:
|
||||
|
|
@ -565,7 +526,7 @@ function inflate(strm, flush) {
|
|||
}
|
||||
//=== NEEDBITS(16);
|
||||
while (bits < 16) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -626,7 +587,7 @@ function inflate(strm, flush) {
|
|||
case FLAGS:
|
||||
//=== NEEDBITS(16); */
|
||||
while (bits < 16) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -662,7 +623,7 @@ function inflate(strm, flush) {
|
|||
case TIME:
|
||||
//=== NEEDBITS(32); */
|
||||
while (bits < 32) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -689,7 +650,7 @@ function inflate(strm, flush) {
|
|||
case OS:
|
||||
//=== NEEDBITS(16); */
|
||||
while (bits < 16) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -716,7 +677,7 @@ function inflate(strm, flush) {
|
|||
if (state.flags & 0x0400) {
|
||||
//=== NEEDBITS(16); */
|
||||
while (bits < 16) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -763,14 +724,14 @@ function inflate(strm, flush) {
|
|||
next += copy;
|
||||
state.length -= copy;
|
||||
}
|
||||
if (state.length) { return inf_leave(); }
|
||||
if (state.length) { break inf_leave; }
|
||||
}
|
||||
state.length = 0;
|
||||
state.mode = NAME;
|
||||
/* falls through */
|
||||
case NAME:
|
||||
if (state.flags & 0x0800) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
copy = 0;
|
||||
do {
|
||||
// TODO: 2 or 1 bytes?
|
||||
|
|
@ -785,7 +746,7 @@ function inflate(strm, flush) {
|
|||
}
|
||||
have -= copy;
|
||||
next += copy;
|
||||
if (len) { return inf_leave(); }
|
||||
if (len) { break inf_leave; }
|
||||
}
|
||||
else if (state.head) {
|
||||
state.head.name = null;
|
||||
|
|
@ -795,7 +756,7 @@ function inflate(strm, flush) {
|
|||
/* falls through */
|
||||
case COMMENT:
|
||||
if (state.flags & 0x1000) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
copy = 0;
|
||||
do {
|
||||
len = input[next + copy++];
|
||||
|
|
@ -809,7 +770,7 @@ function inflate(strm, flush) {
|
|||
}
|
||||
have -= copy;
|
||||
next += copy;
|
||||
if (len) { return inf_leave(); }
|
||||
if (len) { break inf_leave; }
|
||||
}
|
||||
else if (state.head) {
|
||||
state.head.comment = null;
|
||||
|
|
@ -820,7 +781,7 @@ function inflate(strm, flush) {
|
|||
if (state.flags & 0x0200) {
|
||||
//=== NEEDBITS(16); */
|
||||
while (bits < 16) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -846,7 +807,7 @@ function inflate(strm, flush) {
|
|||
case DICTID:
|
||||
//=== NEEDBITS(32); */
|
||||
while (bits < 32) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -861,14 +822,21 @@ function inflate(strm, flush) {
|
|||
/* falls through */
|
||||
case DICT:
|
||||
if (state.havedict === 0) {
|
||||
RESTORE();
|
||||
//--- RESTORE() ---
|
||||
strm.next_out_index = put;
|
||||
strm.avail_out = left;
|
||||
strm.next_in_index = next;
|
||||
strm.avail_in = have;
|
||||
state.hold = hold;
|
||||
state.bits = bits;
|
||||
//---
|
||||
return Z_NEED_DICT;
|
||||
}
|
||||
strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
|
||||
state.mode = TYPE;
|
||||
/* falls through */
|
||||
case TYPE:
|
||||
if (flush === Z_BLOCK || flush === Z_TREES) { return inf_leave(); }
|
||||
if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }
|
||||
/* falls through */
|
||||
case TYPEDO:
|
||||
if (state.last) {
|
||||
|
|
@ -881,7 +849,7 @@ function inflate(strm, flush) {
|
|||
}
|
||||
//=== NEEDBITS(3); */
|
||||
while (bits < 3) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -909,7 +877,7 @@ function inflate(strm, flush) {
|
|||
hold >>>= 2;
|
||||
bits -= 2;
|
||||
//---//
|
||||
return inf_leave();
|
||||
break inf_leave;
|
||||
}
|
||||
break;
|
||||
case 2: /* dynamic block */
|
||||
|
|
@ -933,7 +901,7 @@ function inflate(strm, flush) {
|
|||
//---//
|
||||
//=== NEEDBITS(32); */
|
||||
while (bits < 32) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -952,7 +920,7 @@ function inflate(strm, flush) {
|
|||
bits = 0;
|
||||
//===//
|
||||
state.mode = COPY_;
|
||||
if (flush === Z_TREES) { return inf_leave(); }
|
||||
if (flush === Z_TREES) { break inf_leave; }
|
||||
/* falls through */
|
||||
case COPY_:
|
||||
state.mode = COPY;
|
||||
|
|
@ -962,7 +930,7 @@ function inflate(strm, flush) {
|
|||
if (copy) {
|
||||
if (copy > have) { copy = have; }
|
||||
if (copy > left) { copy = left; }
|
||||
if (copy === 0) { return inf_leave(); }
|
||||
if (copy === 0) { break inf_leave; }
|
||||
//--- zmemcpy(put, next, copy); ---
|
||||
utils.arraySet(output, input, next, copy, put);
|
||||
//---//
|
||||
|
|
@ -979,7 +947,7 @@ function inflate(strm, flush) {
|
|||
case TABLE:
|
||||
//=== NEEDBITS(14); */
|
||||
while (bits < 14) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1015,7 +983,7 @@ function inflate(strm, flush) {
|
|||
while (state.have < state.ncode) {
|
||||
//=== NEEDBITS(3);
|
||||
while (bits < 3) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1055,7 +1023,7 @@ function inflate(strm, flush) {
|
|||
state.lencode.fill(hold & ((1 << state.lenbits) - 1), here);/*BITS(state.lenbits)*/
|
||||
if ((here.bits) <= bits) { break; }
|
||||
//--- PULLBYTE() ---//
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1073,7 +1041,7 @@ function inflate(strm, flush) {
|
|||
//=== NEEDBITS(here.bits + 2);
|
||||
n = here.bits + 2;
|
||||
while (bits < n) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1099,7 +1067,7 @@ function inflate(strm, flush) {
|
|||
//=== NEEDBITS(here.bits + 3);
|
||||
n = here.bits + 3;
|
||||
while (bits < n) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1120,7 +1088,7 @@ function inflate(strm, flush) {
|
|||
//=== NEEDBITS(here.bits + 7);
|
||||
n = here.bits + 7;
|
||||
while (bits < n) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1191,16 +1159,33 @@ function inflate(strm, flush) {
|
|||
}
|
||||
//Tracev((stderr, 'inflate: codes ok\n'));
|
||||
state.mode = LEN_;
|
||||
if (flush === Z_TREES) { return inf_leave(); }
|
||||
if (flush === Z_TREES) { break inf_leave; }
|
||||
/* falls through */
|
||||
case LEN_:
|
||||
state.mode = LEN;
|
||||
/* falls through */
|
||||
case LEN:
|
||||
if (have >= 6 && left >= 258) {
|
||||
RESTORE();
|
||||
//--- RESTORE() ---
|
||||
strm.next_out_index = put;
|
||||
strm.avail_out = left;
|
||||
strm.next_in_index = next;
|
||||
strm.avail_in = have;
|
||||
state.hold = hold;
|
||||
state.bits = bits;
|
||||
//---
|
||||
inflate_fast(strm, _out);
|
||||
LOAD();
|
||||
//--- LOAD() ---
|
||||
put = strm.next_out_index;
|
||||
output = strm.next_out;
|
||||
left = strm.avail_out;
|
||||
next = strm.next_in_index;
|
||||
input = strm.next_in;
|
||||
have = strm.avail_in;
|
||||
hold = state.hold;
|
||||
bits = state.bits;
|
||||
//---
|
||||
|
||||
if (state.mode === TYPE) {
|
||||
state.back = -1;
|
||||
}
|
||||
|
|
@ -1211,7 +1196,7 @@ function inflate(strm, flush) {
|
|||
state.lencode.fill(hold & ((1 << state.lenbits) -1),here); /*BITS(state.lenbits)*/
|
||||
if (here.bits <= bits) { break; }
|
||||
//--- PULLBYTE() ---//
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1224,7 +1209,7 @@ function inflate(strm, flush) {
|
|||
((hold & ((1 << (last.bits + last.op)) -1))/*BITS(last.bits + last.op)*/ >> last.bits), here);
|
||||
if ((last.bits + here.bits) <= bits) { break; }
|
||||
//--- PULLBYTE() ---//
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1268,7 +1253,7 @@ function inflate(strm, flush) {
|
|||
//=== NEEDBITS(state.extra);
|
||||
n = state.extra;
|
||||
while (bits < n) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1290,7 +1275,7 @@ function inflate(strm, flush) {
|
|||
state.distcode.fill(hold & ((1 << state.distbits) -1), here);/*BITS(state.distbits)*/
|
||||
if ((here.bits) <= bits) { break; }
|
||||
//--- PULLBYTE() ---//
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1303,7 +1288,7 @@ function inflate(strm, flush) {
|
|||
((hold & ((1 << (last.bits + last.op)) -1))/*BITS(last.bits + last.op)*/ >> last.bits), here);
|
||||
if ((last.bits + here.bits) <= bits) { break; }
|
||||
//--- PULLBYTE() ---//
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1334,7 +1319,7 @@ function inflate(strm, flush) {
|
|||
//=== NEEDBITS(state.extra);
|
||||
n = state.extra;
|
||||
while (bits < n) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1358,7 +1343,7 @@ function inflate(strm, flush) {
|
|||
state.mode = MATCH;
|
||||
/* falls through */
|
||||
case MATCH:
|
||||
if (left === 0) { return inf_leave(); }
|
||||
if (left === 0) { break inf_leave; }
|
||||
copy = _out - left;
|
||||
if (state.offset > copy) { /* copy from window */
|
||||
copy = state.offset - copy;
|
||||
|
|
@ -1406,7 +1391,7 @@ function inflate(strm, flush) {
|
|||
if (state.length === 0) { state.mode = LEN; }
|
||||
break;
|
||||
case LIT:
|
||||
if (left === 0) { return inf_leave(); }
|
||||
if (left === 0) { break inf_leave; }
|
||||
output[put++] = state.length;
|
||||
left--;
|
||||
state.mode = LEN;
|
||||
|
|
@ -1415,7 +1400,7 @@ function inflate(strm, flush) {
|
|||
if (state.wrap) {
|
||||
//=== NEEDBITS(32);
|
||||
while (bits < 32) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
hold >>>= 0;
|
||||
|
|
@ -1449,7 +1434,7 @@ function inflate(strm, flush) {
|
|||
if (state.wrap && state.flags) {
|
||||
//=== NEEDBITS(32);
|
||||
while (bits < 32) {
|
||||
if (have === 0) { return inf_leave(); }
|
||||
if (have === 0) { break inf_leave; }
|
||||
have--;
|
||||
hold += input[next++] << bits;
|
||||
bits += 8;
|
||||
|
|
@ -1470,10 +1455,10 @@ function inflate(strm, flush) {
|
|||
/* falls through */
|
||||
case DONE:
|
||||
ret = Z_STREAM_END;
|
||||
return inf_leave();
|
||||
break inf_leave;
|
||||
case BAD:
|
||||
ret = Z_DATA_ERROR;
|
||||
return inf_leave();
|
||||
break inf_leave;
|
||||
case MEM:
|
||||
return Z_MEM_ERROR;
|
||||
case SYNC:
|
||||
|
|
@ -1482,6 +1467,48 @@ function inflate(strm, flush) {
|
|||
return Z_STREAM_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
// inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"
|
||||
|
||||
/*
|
||||
Return from inflate(), updating the total counts and the check value.
|
||||
If there was no progress during the inflate() call, return a buffer
|
||||
error. Call updatewindow() to create and/or update the window state.
|
||||
Note: a memory error from inflate() is non-recoverable.
|
||||
*/
|
||||
|
||||
//--- RESTORE() ---
|
||||
strm.next_out_index = put;
|
||||
strm.avail_out = left;
|
||||
strm.next_in_index = next;
|
||||
strm.avail_in = have;
|
||||
state.hold = hold;
|
||||
state.bits = bits;
|
||||
//---
|
||||
|
||||
if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
|
||||
(state.mode < CHECK || flush !== Z_FINISH))) {
|
||||
if (updatewindow(strm, strm.next_out, strm.next_out_index, _out - strm.avail_out)) {
|
||||
state.mode = MEM;
|
||||
return Z_MEM_ERROR;
|
||||
}
|
||||
}
|
||||
_in -= strm.avail_in;
|
||||
_out -= strm.avail_out;
|
||||
strm.total_in += _in;
|
||||
strm.total_out += _out;
|
||||
state.total += _out;
|
||||
if (state.wrap && _out) {
|
||||
strm.adler = state.check = /*UPDATE(state.check, strm.next_out_index - _out, _out);*/
|
||||
(state.flags ? crc32(state.check, output, _out, strm.next_out_index - _out) : adler32(state.check, output, _out, strm.next_out_index - _out));
|
||||
}
|
||||
strm.data_type = state.bits + (state.last ? 64 : 0) +
|
||||
(state.mode === TYPE ? 128 : 0) +
|
||||
(state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
|
||||
if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {
|
||||
ret = Z_BUF_ERROR;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
function inflateEnd(strm) {
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue