0x5eal/rbxts-pako
1
0
Fork 0
mirror of https://github.com/0x5eal/rbxts-pako.git synced 2025-04-05 03:11:04 +01:00
Code Issues Projects Releases Packages Wiki Activity

refactoring: rename input/output buffer indexes to next_in/next_out

Browse source
This commit is contained in:
nik 2014-04-17 18:17:22 -03:00
parent 83859e524b
commit 8bea7480aa
8 changed files with 66 additions and 66 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
lib/deflate.js
View file

@ -200,18 +200,18 @@ Deflate.prototype.push = function(data, mode) {
// Convert data if needed
if (typeof data === 'string') {
// If we need to compress text, change encoding to utf8.
strm.next_in = strings.string2buf(data);
strm.input = strings.string2buf(data);
} else {
strm.next_in = data;
strm.input = data;
}
strm.next_in_index = 0;
strm.avail_in = strm.next_in.length;
strm.next_in = 0;
strm.avail_in = strm.input.length;
do {
if (strm.avail_out === 0) {
strm.next_out = new utils.Buf8(chunkSize);
strm.next_out_index = 0;
strm.output = new utils.Buf8(chunkSize);
strm.next_out = 0;
strm.avail_out = chunkSize;
}
status = zlib_deflate.deflate(strm, _mode); /* no bad return value */
@ -223,9 +223,9 @@ Deflate.prototype.push = function(data, mode) {
}
if (strm.avail_out === 0 || (strm.avail_in === 0 && _mode === Z_FINISH)) {
if (this.options.to === 'string') {
this.onData(strings.buf2binstring(utils.shrinkBuf(strm.next_out, strm.next_out_index)));
this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out)));
} else {
this.onData(utils.shrinkBuf(strm.next_out, strm.next_out_index));
this.onData(utils.shrinkBuf(strm.output, strm.next_out));
}
}
} while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END);

28
lib/inflate.js
View file

@ -175,7 +175,7 @@ Inflate.prototype.push = function(data, mode) {
var strm = this.strm;
var chunkSize = this.options.chunkSize;
var status, _mode;
var next_out_utf8_index, tail, utf8str;
var next_out_utf8, tail, utf8str;
if (this.ended) { return false; }
_mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);
@ -183,18 +183,18 @@ Inflate.prototype.push = function(data, mode) {
// Convert data if needed
if (typeof data === 'string') {
// Only binary strings can be decompressed on practice
strm.next_in = strings.binstring2buf(data);
strm.input = strings.binstring2buf(data);
} else {
strm.next_in = data;
strm.input = data;
}
strm.next_in_index = 0;
strm.avail_in = strm.next_in.length;
strm.next_in = 0;
strm.avail_in = strm.input.length;
do {
if (strm.avail_out === 0) {
strm.next_out = new utils.Buf8(chunkSize);
strm.next_out_index = 0;
strm.output = new utils.Buf8(chunkSize);
strm.next_out = 0;
strm.avail_out = chunkSize;
}
@ -206,25 +206,25 @@ Inflate.prototype.push = function(data, mode) {
return false;
}
if (strm.next_out_index) {
if (strm.next_out) {
if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && _mode === c.Z_FINISH)) {
if (this.options.to === 'string') {
next_out_utf8_index = strings.utf8border(strm.next_out, strm.next_out_index);
next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
tail = strm.next_out_index - next_out_utf8_index;
utf8str = strings.buf2string(strm.next_out, next_out_utf8_index);
tail = strm.next_out - next_out_utf8;
utf8str = strings.buf2string(strm.output, next_out_utf8);
// move tail
strm.next_out_index = tail;
strm.next_out = tail;
strm.avail_out = chunkSize - tail;
if (tail) { utils.arraySet(strm.next_out, strm.next_out, next_out_utf8_index, tail, 0); }
if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); }
this.onData(utf8str);
} else {
this.onData(utils.shrinkBuf(strm.next_out, strm.next_out_index));
this.onData(utils.shrinkBuf(strm.output, strm.next_out));
}
}
}

16
lib/zlib/deflate.js
View file

@ -118,7 +118,7 @@ function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; }
/* =========================================================================
* Flush as much pending output as possible. All deflate() output goes
* through this function so some applications may wish to modify it
* to avoid allocating a large strm->next_out buffer and copying into it.
* to avoid allocating a large strm->output buffer and copying into it.
* (See also read_buf()).
*/
function flush_pending(strm) {
@ -131,8 +131,8 @@ function flush_pending(strm) {
}
if (len === 0) { return; }
utils.arraySet(strm.next_out, s.pending_buf, s.pending_out, len, strm.next_out_index);
strm.next_out_index += len;
utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);
strm.next_out += len;
s.pending_out += len;
strm.total_out += len;
strm.avail_out -= len;
@ -172,7 +172,7 @@ function putShortMSB(s, b) {
* Read a new buffer from the current input stream, update the adler32
* and total number of bytes read. All deflate() input goes through
* this function so some applications may wish to modify it to avoid
* allocating a large strm->next_in buffer and copying from it.
* allocating a large strm->input buffer and copying from it.
* (See also flush_pending()).
*/
function read_buf(strm, buf, start, size) {
@ -183,7 +183,7 @@ function read_buf(strm, buf, start, size) {
strm.avail_in -= len;
utils.arraySet(buf, strm.next_in, strm.next_in_index, len, start);
utils.arraySet(buf, strm.input, strm.next_in, len, start);
if (strm.state.wrap === 1) {
strm.adler = adler32(strm.adler, buf, len, start);
}
@ -192,7 +192,7 @@ function read_buf(strm, buf, start, size) {
strm.adler = crc32(strm.adler, buf, len, start);
}
strm.next_in_index += len;
strm.next_in += len;
strm.total_in += len;
return len;
@ -1391,8 +1391,8 @@ function deflate(strm, flush) {
s = strm.state;
if (!strm.next_out ||
(!strm.next_in && strm.avail_in !== 0) ||
if (!strm.output ||
(!strm.input && strm.avail_in !== 0) ||
(s.status === FINISH_STATE && flush !== Z_FINISH)) {
return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR);
}

18
lib/zlib/inffast.js
View file

@ -41,10 +41,10 @@ var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
*/
module.exports = function inflate_fast(strm, start) {
var state;
var _in; /* local strm.next_in */
var _in; /* local strm.input */
var last; /* have enough input while in < last */
var _out; /* local strm.next_out */
var beg; /* inflate()'s initial strm.next_out */
var _out; /* local strm.output */
var beg; /* inflate()'s initial strm.output */
var end; /* while out < end, enough space available */
//#ifdef INFLATE_STRICT
var dmax; /* maximum distance from zlib header */
@ -73,11 +73,11 @@ module.exports = function inflate_fast(strm, start) {
/* copy state to local variables */
state = strm.state;
//here = state.here;
_in = strm.next_in_index;
input = strm.next_in;
_in = strm.next_in;
input = strm.input;
last = _in + (strm.avail_in - 5);
_out = strm.next_out_index;
output = strm.next_out;
_out = strm.next_out;
output = strm.output;
beg = _out - (start - strm.avail_out);
end = _out + (strm.avail_out - 257);
//#ifdef INFLATE_STRICT
@ -315,8 +315,8 @@ module.exports = function inflate_fast(strm, start) {
hold &= (1 << bits) - 1;
/* update state and return */
strm.next_in_index = _in;
strm.next_out_index = _out;
strm.next_in = _in;
strm.next_out = _out;
strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
state.hold = hold;

38
lib/zlib/inflate.js
View file

@ -384,8 +384,8 @@ function inflate(strm, flush) {
[16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
if (!strm || !strm.state || !strm.next_out ||
(!strm.next_in && strm.avail_in !== 0)) {
if (!strm || !strm.state || !strm.output ||
(!strm.input && strm.avail_in !== 0)) {
return Z_STREAM_ERROR;
}
@ -394,11 +394,11 @@ function inflate(strm, flush) {
//--- LOAD() ---
put = strm.next_out_index;
output = strm.next_out;
put = strm.next_out;
output = strm.output;
left = strm.avail_out;
next = strm.next_in_index;
input = strm.next_in;
next = strm.next_in;
input = strm.input;
have = strm.avail_in;
hold = state.hold;
bits = state.bits;
@ -724,9 +724,9 @@ function inflate(strm, flush) {
case DICT:
if (state.havedict === 0) {
//--- RESTORE() ---
strm.next_out_index = put;
strm.next_out = put;
strm.avail_out = left;
strm.next_in_index = next;
strm.next_in = next;
strm.avail_in = have;
state.hold = hold;
state.bits = bits;
@ -1076,20 +1076,20 @@ function inflate(strm, flush) {
case LEN:
if (have >= 6 && left >= 258) {
//--- RESTORE() ---
strm.next_out_index = put;
strm.next_out = put;
strm.avail_out = left;
strm.next_in_index = next;
strm.next_in = next;
strm.avail_in = have;
state.hold = hold;
state.bits = bits;
//---
inflate_fast(strm, _out);
//--- LOAD() ---
put = strm.next_out_index;
output = strm.next_out;
put = strm.next_out;
output = strm.output;
left = strm.avail_out;
next = strm.next_in_index;
input = strm.next_in;
next = strm.next_in;
input = strm.input;
have = strm.avail_in;
hold = state.hold;
bits = state.bits;
@ -1410,9 +1410,9 @@ function inflate(strm, flush) {
*/
//--- RESTORE() ---
strm.next_out_index = put;
strm.next_out = put;
strm.avail_out = left;
strm.next_in_index = next;
strm.next_in = next;
strm.avail_in = have;
state.hold = hold;
state.bits = bits;
@ -1420,7 +1420,7 @@ function inflate(strm, flush) {
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)) {
if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {
state.mode = MEM;
return Z_MEM_ERROR;
}
@ -1431,8 +1431,8 @@ function inflate(strm, flush) {
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.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
(state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
}
strm.data_type = state.bits + (state.last ? 64 : 0) +
(state.mode === TYPE ? 128 : 0) +

12
lib/zlib/zstream.js
View file

@ -3,16 +3,16 @@
function ZStream() {
/* next input byte */
this.next_in = null;
this.next_in_index = 0; // JS specific, offset in next_in
/* number of bytes available at next_in */
this.input = null;
this.next_in = 0; // JS specific, offset in input
/* number of bytes available at input */
this.avail_in = 0;
/* total number of input bytes read so far */
this.total_in = 0;
/* next output byte should be put there */
this.next_out = null;
this.next_out_index = 0; // JS specific, offset in next_out
/* remaining free space at next_out */
this.output = null;
this.next_out = 0; // JS specific, offset in output
/* remaining free space at output */
this.avail_out = 0;
/* total number of bytes output so far */
this.total_out = 0;

2
test/gzip_specials.js
View file

@ -75,7 +75,7 @@ describe('Gzip special cases', function() {
assert(!inflator.err, inflator.msg);
pos += strm.next_in_index;
pos += strm.next_in;
i++;
} while (strm.avail_in);

2
test/inflate_cover_ported.js
View file

@ -210,7 +210,7 @@ describe('Inflate support', function() {
var ret;
var strm = new zlib_stream();
strm.avail_in = 0;
strm.next_in = null;
strm.input = null;
ret = zlib_inflate.inflateInit(strm);
assert(ret === c.Z_OK);