zlib: move constants into zlib.constants
zlib constants were previously being added to binding in node_zlib.cc. This moves the zlib constants to node_constants.cc for consistency with the recent constants refactoring: https://github.com/nodejs/node/pull/6534 Adds require('zlib').constants to expose the constants Docs-only deprecates the constants hung directly off require('zlib') Removes a couple constants from the docs that apparently no longer exist in the code PR-URL: https://github.com/nodejs/node/pull/7203 Reviewed-By: Rod Vagg <rod@vagg.org> Reviewed-By: Anna Henningsen <anna@addaleax.net> Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
This commit is contained in:
James M Snell
Родитель
a173483619
Коммит
197a465280
|
|
@ -123,7 +123,9 @@ method that is used to compressed the last chunk of input data:
|
|||
// This is a truncated version of the buffer from the above examples
|
||||
const buffer = Buffer.from('eJzT0yMA', 'base64');
|
||||
|
||||
zlib.unzip(buffer, { finishFlush: zlib.Z_SYNC_FLUSH }, (err, buffer) => {
|
||||
zlib.unzip(buffer,
|
||||
{finishFlush: zlib.constants.Z_SYNC_FLUSH},
|
||||
(err, buffer) => {
|
||||
if (!err) {
|
||||
console.log(buffer.toString());
|
||||
} else {
|
||||
|
|
@ -221,65 +223,56 @@ added: v0.5.8
|
|||
|
||||
<!--type=misc-->
|
||||
|
||||
All of the constants defined in `zlib.h` are also defined on `require('zlib')`.
|
||||
In the normal course of operations, it will not be necessary to use these
|
||||
constants. They are documented so that their presence is not surprising. This
|
||||
section is taken almost directly from the [zlib documentation][]. See
|
||||
<http://zlib.net/manual.html#Constants> for more details.
|
||||
All of the constants defined in `zlib.h` are also defined on
|
||||
`require('zlib').constants`. In the normal course of operations, it will not be
|
||||
necessary to use these constants. They are documented so that their presence is
|
||||
not surprising. This section is taken almost directly from the
|
||||
[zlib documentation][]. See <http://zlib.net/manual.html#Constants> for more
|
||||
details.
|
||||
|
||||
*Note*: Previously, the constants were available directly from
|
||||
`require('zlib')`, for instance `zlib.Z_NO_FLUSH`. Accessing the constants
|
||||
directly from the module is currently still possible but should be considered
|
||||
deprecated.
|
||||
|
||||
Allowed flush values.
|
||||
|
||||
* `zlib.Z_NO_FLUSH`
|
||||
* `zlib.Z_PARTIAL_FLUSH`
|
||||
* `zlib.Z_SYNC_FLUSH`
|
||||
* `zlib.Z_FULL_FLUSH`
|
||||
* `zlib.Z_FINISH`
|
||||
* `zlib.Z_BLOCK`
|
||||
* `zlib.Z_TREES`
|
||||
* `zlib.constants.Z_NO_FLUSH`
|
||||
* `zlib.constants.Z_PARTIAL_FLUSH`
|
||||
* `zlib.constants.Z_SYNC_FLUSH`
|
||||
* `zlib.constants.Z_FULL_FLUSH`
|
||||
* `zlib.constants.Z_FINISH`
|
||||
* `zlib.constants.Z_BLOCK`
|
||||
* `zlib.constants.Z_TREES`
|
||||
|
||||
Return codes for the compression/decompression functions. Negative
|
||||
values are errors, positive values are used for special but normal
|
||||
events.
|
||||
|
||||
* `zlib.Z_OK`
|
||||
* `zlib.Z_STREAM_END`
|
||||
* `zlib.Z_NEED_DICT`
|
||||
* `zlib.Z_ERRNO`
|
||||
* `zlib.Z_STREAM_ERROR`
|
||||
* `zlib.Z_DATA_ERROR`
|
||||
* `zlib.Z_MEM_ERROR`
|
||||
* `zlib.Z_BUF_ERROR`
|
||||
* `zlib.Z_VERSION_ERROR`
|
||||
* `zlib.constants.Z_OK`
|
||||
* `zlib.constants.Z_STREAM_END`
|
||||
* `zlib.constants.Z_NEED_DICT`
|
||||
* `zlib.constants.Z_ERRNO`
|
||||
* `zlib.constants.Z_STREAM_ERROR`
|
||||
* `zlib.constants.Z_DATA_ERROR`
|
||||
* `zlib.constants.Z_MEM_ERROR`
|
||||
* `zlib.constants.Z_BUF_ERROR`
|
||||
* `zlib.constants.Z_VERSION_ERROR`
|
||||
|
||||
Compression levels.
|
||||
|
||||
* `zlib.Z_NO_COMPRESSION`
|
||||
* `zlib.Z_BEST_SPEED`
|
||||
* `zlib.Z_BEST_COMPRESSION`
|
||||
* `zlib.Z_DEFAULT_COMPRESSION`
|
||||
* `zlib.constants.Z_NO_COMPRESSION`
|
||||
* `zlib.constants.Z_BEST_SPEED`
|
||||
* `zlib.constants.Z_BEST_COMPRESSION`
|
||||
* `zlib.constants.Z_DEFAULT_COMPRESSION`
|
||||
|
||||
Compression strategy.
|
||||
|
||||
* `zlib.Z_FILTERED`
|
||||
* `zlib.Z_HUFFMAN_ONLY`
|
||||
* `zlib.Z_RLE`
|
||||
* `zlib.Z_FIXED`
|
||||
* `zlib.Z_DEFAULT_STRATEGY`
|
||||
|
||||
Possible values of the data_type field.
|
||||
|
||||
* `zlib.Z_BINARY`
|
||||
* `zlib.Z_TEXT`
|
||||
* `zlib.Z_ASCII`
|
||||
* `zlib.Z_UNKNOWN`
|
||||
|
||||
The deflate compression method (the only one supported in this version).
|
||||
|
||||
* `zlib.Z_DEFLATED`
|
||||
|
||||
For initializing zalloc, zfree, opaque.
|
||||
|
||||
* `zlib.Z_NULL`
|
||||
* `zlib.constants.Z_FILTERED`
|
||||
* `zlib.constants.Z_HUFFMAN_ONLY`
|
||||
* `zlib.constants.Z_RLE`
|
||||
* `zlib.constants.Z_FIXED`
|
||||
* `zlib.constants.Z_DEFAULT_STRATEGY`
|
||||
|
||||
## Class Options
|
||||
<!-- YAML
|
||||
|
|
@ -293,8 +286,8 @@ Each class takes an `options` object. All options are optional.
|
|||
Note that some options are only relevant when compressing, and are
|
||||
ignored by the decompression classes.
|
||||
|
||||
* `flush` (default: `zlib.Z_NO_FLUSH`)
|
||||
* `finishFlush` (default: `zlib.Z_FINISH`)
|
||||
* `flush` (default: `zlib.constants.Z_NO_FLUSH`)
|
||||
* `finishFlush` (default: `zlib.constants.Z_FINISH`)
|
||||
* `chunkSize` (default: 16*1024)
|
||||
* `windowBits`
|
||||
* `level` (compression only)
|
||||
|
|
@ -368,7 +361,7 @@ class of the compressor/decompressor classes.
|
|||
added: v0.5.8
|
||||
-->
|
||||
|
||||
`kind` defaults to `zlib.Z_FULL_FLUSH`.
|
||||
`kind` defaults to `zlib.constants.Z_FULL_FLUSH`.
|
||||
|
||||
Flush pending data. Don't call this frivolously, premature flushes negatively
|
||||
impact the effectiveness of the compression algorithm.
|
||||
|
|
@ -391,6 +384,10 @@ Only applicable to deflate algorithm.
|
|||
added: v0.7.0
|
||||
-->
|
||||
|
||||
## zlib.constants
|
||||
|
||||
Provides an object enumerating Zlib-related [constants][].
|
||||
|
||||
Reset the compressor/decompressor to factory defaults. Only applicable to
|
||||
the inflate and deflate algorithms.
|
||||
|
||||
|
|
@ -545,3 +542,4 @@ Decompress a Buffer or string with Unzip.
|
|||
[Unzip]: #zlib_class_zlib_unzip
|
||||
[`.flush()`]: #zlib_zlib_flush_kind_callback
|
||||
[Buffer]: buffer.html
|
||||
[constants]: #constants_constants
|
||||
|
|
|
|||
142
lib/zlib.js
142
lib/zlib.js
|
|
@ -9,49 +9,35 @@ const kMaxLength = require('buffer').kMaxLength;
|
|||
const kRangeErrorMessage = 'Cannot create final Buffer. It would be larger ' +
|
||||
'than 0x' + kMaxLength.toString(16) + ' bytes';
|
||||
|
||||
// zlib doesn't provide these, so kludge them in following the same
|
||||
// const naming scheme zlib uses.
|
||||
binding.Z_MIN_WINDOWBITS = 8;
|
||||
binding.Z_MAX_WINDOWBITS = 15;
|
||||
binding.Z_DEFAULT_WINDOWBITS = 15;
|
||||
|
||||
// fewer than 64 bytes per chunk is stupid.
|
||||
// technically it could work with as few as 8, but even 64 bytes
|
||||
// is absurdly low. Usually a MB or more is best.
|
||||
binding.Z_MIN_CHUNK = 64;
|
||||
binding.Z_MAX_CHUNK = Infinity;
|
||||
binding.Z_DEFAULT_CHUNK = (16 * 1024);
|
||||
|
||||
binding.Z_MIN_MEMLEVEL = 1;
|
||||
binding.Z_MAX_MEMLEVEL = 9;
|
||||
binding.Z_DEFAULT_MEMLEVEL = 8;
|
||||
|
||||
binding.Z_MIN_LEVEL = -1;
|
||||
binding.Z_MAX_LEVEL = 9;
|
||||
binding.Z_DEFAULT_LEVEL = binding.Z_DEFAULT_COMPRESSION;
|
||||
const constants = process.binding('constants').zlib;
|
||||
|
||||
// These should be considered deprecated
|
||||
// expose all the zlib constants
|
||||
const bkeys = Object.keys(binding);
|
||||
const bkeys = Object.keys(constants);
|
||||
for (var bk = 0; bk < bkeys.length; bk++) {
|
||||
var bkey = bkeys[bk];
|
||||
if (bkey.match(/^Z/)) {
|
||||
Object.defineProperty(exports, bkey, {
|
||||
enumerable: true, value: binding[bkey], writable: false
|
||||
});
|
||||
}
|
||||
Object.defineProperty(exports, bkey, {
|
||||
enumerable: true, value: constants[bkey], writable: false
|
||||
});
|
||||
}
|
||||
|
||||
Object.defineProperty(exports, 'constants', {
|
||||
configurable: false,
|
||||
enumerable: true,
|
||||
value: constants
|
||||
});
|
||||
|
||||
// translation table for return codes.
|
||||
const codes = {
|
||||
Z_OK: binding.Z_OK,
|
||||
Z_STREAM_END: binding.Z_STREAM_END,
|
||||
Z_NEED_DICT: binding.Z_NEED_DICT,
|
||||
Z_ERRNO: binding.Z_ERRNO,
|
||||
Z_STREAM_ERROR: binding.Z_STREAM_ERROR,
|
||||
Z_DATA_ERROR: binding.Z_DATA_ERROR,
|
||||
Z_MEM_ERROR: binding.Z_MEM_ERROR,
|
||||
Z_BUF_ERROR: binding.Z_BUF_ERROR,
|
||||
Z_VERSION_ERROR: binding.Z_VERSION_ERROR
|
||||
Z_OK: constants.Z_OK,
|
||||
Z_STREAM_END: constants.Z_STREAM_END,
|
||||
Z_NEED_DICT: constants.Z_NEED_DICT,
|
||||
Z_ERRNO: constants.Z_ERRNO,
|
||||
Z_STREAM_ERROR: constants.Z_STREAM_ERROR,
|
||||
Z_DATA_ERROR: constants.Z_DATA_ERROR,
|
||||
Z_MEM_ERROR: constants.Z_MEM_ERROR,
|
||||
Z_BUF_ERROR: constants.Z_BUF_ERROR,
|
||||
Z_VERSION_ERROR: constants.Z_VERSION_ERROR
|
||||
};
|
||||
|
||||
const ckeys = Object.keys(codes);
|
||||
|
|
@ -243,52 +229,52 @@ function zlibBufferSync(engine, buffer) {
|
|||
// minimal 2-byte header
|
||||
function Deflate(opts) {
|
||||
if (!(this instanceof Deflate)) return new Deflate(opts);
|
||||
Zlib.call(this, opts, binding.DEFLATE);
|
||||
Zlib.call(this, opts, constants.DEFLATE);
|
||||
}
|
||||
|
||||
function Inflate(opts) {
|
||||
if (!(this instanceof Inflate)) return new Inflate(opts);
|
||||
Zlib.call(this, opts, binding.INFLATE);
|
||||
Zlib.call(this, opts, constants.INFLATE);
|
||||
}
|
||||
|
||||
|
||||
// gzip - bigger header, same deflate compression
|
||||
function Gzip(opts) {
|
||||
if (!(this instanceof Gzip)) return new Gzip(opts);
|
||||
Zlib.call(this, opts, binding.GZIP);
|
||||
Zlib.call(this, opts, constants.GZIP);
|
||||
}
|
||||
|
||||
function Gunzip(opts) {
|
||||
if (!(this instanceof Gunzip)) return new Gunzip(opts);
|
||||
Zlib.call(this, opts, binding.GUNZIP);
|
||||
Zlib.call(this, opts, constants.GUNZIP);
|
||||
}
|
||||
|
||||
|
||||
// raw - no header
|
||||
function DeflateRaw(opts) {
|
||||
if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts);
|
||||
Zlib.call(this, opts, binding.DEFLATERAW);
|
||||
Zlib.call(this, opts, constants.DEFLATERAW);
|
||||
}
|
||||
|
||||
function InflateRaw(opts) {
|
||||
if (!(this instanceof InflateRaw)) return new InflateRaw(opts);
|
||||
Zlib.call(this, opts, binding.INFLATERAW);
|
||||
Zlib.call(this, opts, constants.INFLATERAW);
|
||||
}
|
||||
|
||||
|
||||
// auto-detect header.
|
||||
function Unzip(opts) {
|
||||
if (!(this instanceof Unzip)) return new Unzip(opts);
|
||||
Zlib.call(this, opts, binding.UNZIP);
|
||||
Zlib.call(this, opts, constants.UNZIP);
|
||||
}
|
||||
|
||||
function isValidFlushFlag(flag) {
|
||||
return flag === binding.Z_NO_FLUSH ||
|
||||
flag === binding.Z_PARTIAL_FLUSH ||
|
||||
flag === binding.Z_SYNC_FLUSH ||
|
||||
flag === binding.Z_FULL_FLUSH ||
|
||||
flag === binding.Z_FINISH ||
|
||||
flag === binding.Z_BLOCK;
|
||||
return flag === constants.Z_NO_FLUSH ||
|
||||
flag === constants.Z_PARTIAL_FLUSH ||
|
||||
flag === constants.Z_SYNC_FLUSH ||
|
||||
flag === constants.Z_FULL_FLUSH ||
|
||||
flag === constants.Z_FINISH ||
|
||||
flag === constants.Z_BLOCK;
|
||||
}
|
||||
|
||||
// the Zlib class they all inherit from
|
||||
|
|
@ -298,7 +284,7 @@ function isValidFlushFlag(flag) {
|
|||
|
||||
function Zlib(opts, mode) {
|
||||
this._opts = opts = opts || {};
|
||||
this._chunkSize = opts.chunkSize || exports.Z_DEFAULT_CHUNK;
|
||||
this._chunkSize = opts.chunkSize || constants.Z_DEFAULT_CHUNK;
|
||||
|
||||
Transform.call(this, opts);
|
||||
|
||||
|
|
@ -309,44 +295,44 @@ function Zlib(opts, mode) {
|
|||
throw new Error('Invalid flush flag: ' + opts.finishFlush);
|
||||
}
|
||||
|
||||
this._flushFlag = opts.flush || binding.Z_NO_FLUSH;
|
||||
this._flushFlag = opts.flush || constants.Z_NO_FLUSH;
|
||||
this._finishFlushFlag = typeof opts.finishFlush !== 'undefined' ?
|
||||
opts.finishFlush : binding.Z_FINISH;
|
||||
opts.finishFlush : constants.Z_FINISH;
|
||||
|
||||
if (opts.chunkSize) {
|
||||
if (opts.chunkSize < exports.Z_MIN_CHUNK ||
|
||||
opts.chunkSize > exports.Z_MAX_CHUNK) {
|
||||
if (opts.chunkSize < constants.Z_MIN_CHUNK ||
|
||||
opts.chunkSize > constants.Z_MAX_CHUNK) {
|
||||
throw new Error('Invalid chunk size: ' + opts.chunkSize);
|
||||
}
|
||||
}
|
||||
|
||||
if (opts.windowBits) {
|
||||
if (opts.windowBits < exports.Z_MIN_WINDOWBITS ||
|
||||
opts.windowBits > exports.Z_MAX_WINDOWBITS) {
|
||||
if (opts.windowBits < constants.Z_MIN_WINDOWBITS ||
|
||||
opts.windowBits > constants.Z_MAX_WINDOWBITS) {
|
||||
throw new Error('Invalid windowBits: ' + opts.windowBits);
|
||||
}
|
||||
}
|
||||
|
||||
if (opts.level) {
|
||||
if (opts.level < exports.Z_MIN_LEVEL ||
|
||||
opts.level > exports.Z_MAX_LEVEL) {
|
||||
if (opts.level < constants.Z_MIN_LEVEL ||
|
||||
opts.level > constants.Z_MAX_LEVEL) {
|
||||
throw new Error('Invalid compression level: ' + opts.level);
|
||||
}
|
||||
}
|
||||
|
||||
if (opts.memLevel) {
|
||||
if (opts.memLevel < exports.Z_MIN_MEMLEVEL ||
|
||||
opts.memLevel > exports.Z_MAX_MEMLEVEL) {
|
||||
if (opts.memLevel < constants.Z_MIN_MEMLEVEL ||
|
||||
opts.memLevel > constants.Z_MAX_MEMLEVEL) {
|
||||
throw new Error('Invalid memLevel: ' + opts.memLevel);
|
||||
}
|
||||
}
|
||||
|
||||
if (opts.strategy) {
|
||||
if (opts.strategy != exports.Z_FILTERED &&
|
||||
opts.strategy != exports.Z_HUFFMAN_ONLY &&
|
||||
opts.strategy != exports.Z_RLE &&
|
||||
opts.strategy != exports.Z_FIXED &&
|
||||
opts.strategy != exports.Z_DEFAULT_STRATEGY) {
|
||||
if (opts.strategy != constants.Z_FILTERED &&
|
||||
opts.strategy != constants.Z_HUFFMAN_ONLY &&
|
||||
opts.strategy != constants.Z_RLE &&
|
||||
opts.strategy != constants.Z_FIXED &&
|
||||
opts.strategy != constants.Z_DEFAULT_STRATEGY) {
|
||||
throw new Error('Invalid strategy: ' + opts.strategy);
|
||||
}
|
||||
}
|
||||
|
|
@ -373,15 +359,15 @@ function Zlib(opts, mode) {
|
|||
self.emit('error', error);
|
||||
};
|
||||
|
||||
var level = exports.Z_DEFAULT_COMPRESSION;
|
||||
var level = constants.Z_DEFAULT_COMPRESSION;
|
||||
if (typeof opts.level === 'number') level = opts.level;
|
||||
|
||||
var strategy = exports.Z_DEFAULT_STRATEGY;
|
||||
var strategy = constants.Z_DEFAULT_STRATEGY;
|
||||
if (typeof opts.strategy === 'number') strategy = opts.strategy;
|
||||
|
||||
this._handle.init(opts.windowBits || exports.Z_DEFAULT_WINDOWBITS,
|
||||
this._handle.init(opts.windowBits || constants.Z_DEFAULT_WINDOWBITS,
|
||||
level,
|
||||
opts.memLevel || exports.Z_DEFAULT_MEMLEVEL,
|
||||
opts.memLevel || constants.Z_DEFAULT_MEMLEVEL,
|
||||
strategy,
|
||||
opts.dictionary);
|
||||
|
||||
|
|
@ -402,21 +388,21 @@ function Zlib(opts, mode) {
|
|||
util.inherits(Zlib, Transform);
|
||||
|
||||
Zlib.prototype.params = function(level, strategy, callback) {
|
||||
if (level < exports.Z_MIN_LEVEL ||
|
||||
level > exports.Z_MAX_LEVEL) {
|
||||
if (level < constants.Z_MIN_LEVEL ||
|
||||
level > constants.Z_MAX_LEVEL) {
|
||||
throw new RangeError('Invalid compression level: ' + level);
|
||||
}
|
||||
if (strategy != exports.Z_FILTERED &&
|
||||
strategy != exports.Z_HUFFMAN_ONLY &&
|
||||
strategy != exports.Z_RLE &&
|
||||
strategy != exports.Z_FIXED &&
|
||||
strategy != exports.Z_DEFAULT_STRATEGY) {
|
||||
if (strategy != constants.Z_FILTERED &&
|
||||
strategy != constants.Z_HUFFMAN_ONLY &&
|
||||
strategy != constants.Z_RLE &&
|
||||
strategy != constants.Z_FIXED &&
|
||||
strategy != constants.Z_DEFAULT_STRATEGY) {
|
||||
throw new TypeError('Invalid strategy: ' + strategy);
|
||||
}
|
||||
|
||||
if (this._level !== level || this._strategy !== strategy) {
|
||||
var self = this;
|
||||
this.flush(binding.Z_SYNC_FLUSH, function() {
|
||||
this.flush(constants.Z_SYNC_FLUSH, function() {
|
||||
assert(self._handle, 'zlib binding closed');
|
||||
self._handle.params(level, strategy);
|
||||
if (!self._hadError) {
|
||||
|
|
@ -446,7 +432,7 @@ Zlib.prototype.flush = function(kind, callback) {
|
|||
|
||||
if (typeof kind === 'function' || (kind === undefined && !callback)) {
|
||||
callback = kind;
|
||||
kind = binding.Z_FULL_FLUSH;
|
||||
kind = constants.Z_FULL_FLUSH;
|
||||
}
|
||||
|
||||
if (ws.ended) {
|
||||
|
|
@ -510,7 +496,7 @@ Zlib.prototype._transform = function(chunk, encoding, cb) {
|
|||
// once we've flushed the last of the queue, stop flushing and
|
||||
// go back to the normal behavior.
|
||||
if (chunk.length >= ws.length) {
|
||||
this._flushFlag = this._opts.flush || binding.Z_NO_FLUSH;
|
||||
this._flushFlag = this._opts.flush || constants.Z_NO_FLUSH;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
#include "env-inl.h"
|
||||
|
||||
#include "uv.h"
|
||||
#include "zlib.h"
|
||||
|
||||
#include <errno.h>
|
||||
#if !defined(_MSC_VER)
|
||||
|
|
@ -12,6 +13,7 @@
|
|||
#include <signal.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <limits>
|
||||
|
||||
#if HAVE_OPENSSL
|
||||
# include <openssl/ec.h>
|
||||
|
|
@ -1142,12 +1144,92 @@ void DefineCryptoConstants(Local<Object> target) {
|
|||
#endif
|
||||
}
|
||||
|
||||
void DefineZlibConstants(Local<Object> target) {
|
||||
NODE_DEFINE_CONSTANT(target, Z_NO_FLUSH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_PARTIAL_FLUSH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_SYNC_FLUSH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_FULL_FLUSH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_FINISH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_BLOCK);
|
||||
|
||||
// return/error codes
|
||||
NODE_DEFINE_CONSTANT(target, Z_OK);
|
||||
NODE_DEFINE_CONSTANT(target, Z_STREAM_END);
|
||||
NODE_DEFINE_CONSTANT(target, Z_NEED_DICT);
|
||||
NODE_DEFINE_CONSTANT(target, Z_ERRNO);
|
||||
NODE_DEFINE_CONSTANT(target, Z_STREAM_ERROR);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DATA_ERROR);
|
||||
NODE_DEFINE_CONSTANT(target, Z_MEM_ERROR);
|
||||
NODE_DEFINE_CONSTANT(target, Z_BUF_ERROR);
|
||||
NODE_DEFINE_CONSTANT(target, Z_VERSION_ERROR);
|
||||
|
||||
NODE_DEFINE_CONSTANT(target, Z_NO_COMPRESSION);
|
||||
NODE_DEFINE_CONSTANT(target, Z_BEST_SPEED);
|
||||
NODE_DEFINE_CONSTANT(target, Z_BEST_COMPRESSION);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DEFAULT_COMPRESSION);
|
||||
NODE_DEFINE_CONSTANT(target, Z_FILTERED);
|
||||
NODE_DEFINE_CONSTANT(target, Z_HUFFMAN_ONLY);
|
||||
NODE_DEFINE_CONSTANT(target, Z_RLE);
|
||||
NODE_DEFINE_CONSTANT(target, Z_FIXED);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DEFAULT_STRATEGY);
|
||||
NODE_DEFINE_CONSTANT(target, ZLIB_VERNUM);
|
||||
|
||||
enum node_zlib_mode {
|
||||
NONE,
|
||||
DEFLATE,
|
||||
INFLATE,
|
||||
GZIP,
|
||||
GUNZIP,
|
||||
DEFLATERAW,
|
||||
INFLATERAW,
|
||||
UNZIP
|
||||
};
|
||||
|
||||
NODE_DEFINE_CONSTANT(target, DEFLATE);
|
||||
NODE_DEFINE_CONSTANT(target, INFLATE);
|
||||
NODE_DEFINE_CONSTANT(target, GZIP);
|
||||
NODE_DEFINE_CONSTANT(target, GUNZIP);
|
||||
NODE_DEFINE_CONSTANT(target, DEFLATERAW);
|
||||
NODE_DEFINE_CONSTANT(target, INFLATERAW);
|
||||
NODE_DEFINE_CONSTANT(target, UNZIP);
|
||||
|
||||
#define Z_MIN_WINDOWBITS 8
|
||||
#define Z_MAX_WINDOWBITS 15
|
||||
#define Z_DEFAULT_WINDOWBITS 15
|
||||
// Fewer than 64 bytes per chunk is not recommended.
|
||||
// Technically it could work with as few as 8, but even 64 bytes
|
||||
// is low. Usually a MB or more is best.
|
||||
#define Z_MIN_CHUNK 64
|
||||
#define Z_MAX_CHUNK std::numeric_limits<double>::infinity()
|
||||
#define Z_DEFAULT_CHUNK (16 * 1024)
|
||||
#define Z_MIN_MEMLEVEL 1
|
||||
#define Z_MAX_MEMLEVEL 9
|
||||
#define Z_DEFAULT_MEMLEVEL 8
|
||||
#define Z_MIN_LEVEL -1
|
||||
#define Z_MAX_LEVEL 9
|
||||
#define Z_DEFAULT_LEVEL Z_DEFAULT_COMPRESSION
|
||||
|
||||
NODE_DEFINE_CONSTANT(target, Z_MIN_WINDOWBITS);
|
||||
NODE_DEFINE_CONSTANT(target, Z_MAX_WINDOWBITS);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DEFAULT_WINDOWBITS);
|
||||
NODE_DEFINE_CONSTANT(target, Z_MIN_CHUNK);
|
||||
NODE_DEFINE_CONSTANT(target, Z_MAX_CHUNK);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DEFAULT_CHUNK);
|
||||
NODE_DEFINE_CONSTANT(target, Z_MIN_MEMLEVEL);
|
||||
NODE_DEFINE_CONSTANT(target, Z_MAX_MEMLEVEL);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DEFAULT_MEMLEVEL);
|
||||
NODE_DEFINE_CONSTANT(target, Z_MIN_LEVEL);
|
||||
NODE_DEFINE_CONSTANT(target, Z_MAX_LEVEL);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DEFAULT_LEVEL);
|
||||
}
|
||||
|
||||
void DefineConstants(v8::Isolate* isolate, Local<Object> target) {
|
||||
Local<Object> os_constants = Object::New(isolate);
|
||||
Local<Object> err_constants = Object::New(isolate);
|
||||
Local<Object> sig_constants = Object::New(isolate);
|
||||
Local<Object> fs_constants = Object::New(isolate);
|
||||
Local<Object> crypto_constants = Object::New(isolate);
|
||||
Local<Object> zlib_constants = Object::New(isolate);
|
||||
|
||||
DefineErrnoConstants(err_constants);
|
||||
DefineWindowsErrorConstants(err_constants);
|
||||
|
|
@ -1156,12 +1238,14 @@ void DefineConstants(v8::Isolate* isolate, Local<Object> target) {
|
|||
DefineSystemConstants(fs_constants);
|
||||
DefineOpenSSLConstants(crypto_constants);
|
||||
DefineCryptoConstants(crypto_constants);
|
||||
DefineZlibConstants(zlib_constants);
|
||||
|
||||
os_constants->Set(OneByteString(isolate, "errno"), err_constants);
|
||||
os_constants->Set(OneByteString(isolate, "signals"), sig_constants);
|
||||
target->Set(OneByteString(isolate, "os"), os_constants);
|
||||
target->Set(OneByteString(isolate, "fs"), fs_constants);
|
||||
target->Set(OneByteString(isolate, "crypto"), crypto_constants);
|
||||
target->Set(OneByteString(isolate, "zlib"), zlib_constants);
|
||||
}
|
||||
|
||||
} // namespace node
|
||||
|
|
|
|||
|
|
@ -666,44 +666,6 @@ void InitZlib(Local<Object> target,
|
|||
z->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Zlib"));
|
||||
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Zlib"), z->GetFunction());
|
||||
|
||||
// valid flush values.
|
||||
NODE_DEFINE_CONSTANT(target, Z_NO_FLUSH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_PARTIAL_FLUSH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_SYNC_FLUSH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_FULL_FLUSH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_FINISH);
|
||||
NODE_DEFINE_CONSTANT(target, Z_BLOCK);
|
||||
|
||||
// return/error codes
|
||||
NODE_DEFINE_CONSTANT(target, Z_OK);
|
||||
NODE_DEFINE_CONSTANT(target, Z_STREAM_END);
|
||||
NODE_DEFINE_CONSTANT(target, Z_NEED_DICT);
|
||||
NODE_DEFINE_CONSTANT(target, Z_ERRNO);
|
||||
NODE_DEFINE_CONSTANT(target, Z_STREAM_ERROR);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DATA_ERROR);
|
||||
NODE_DEFINE_CONSTANT(target, Z_MEM_ERROR);
|
||||
NODE_DEFINE_CONSTANT(target, Z_BUF_ERROR);
|
||||
NODE_DEFINE_CONSTANT(target, Z_VERSION_ERROR);
|
||||
|
||||
NODE_DEFINE_CONSTANT(target, Z_NO_COMPRESSION);
|
||||
NODE_DEFINE_CONSTANT(target, Z_BEST_SPEED);
|
||||
NODE_DEFINE_CONSTANT(target, Z_BEST_COMPRESSION);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DEFAULT_COMPRESSION);
|
||||
NODE_DEFINE_CONSTANT(target, Z_FILTERED);
|
||||
NODE_DEFINE_CONSTANT(target, Z_HUFFMAN_ONLY);
|
||||
NODE_DEFINE_CONSTANT(target, Z_RLE);
|
||||
NODE_DEFINE_CONSTANT(target, Z_FIXED);
|
||||
NODE_DEFINE_CONSTANT(target, Z_DEFAULT_STRATEGY);
|
||||
NODE_DEFINE_CONSTANT(target, ZLIB_VERNUM);
|
||||
|
||||
NODE_DEFINE_CONSTANT(target, DEFLATE);
|
||||
NODE_DEFINE_CONSTANT(target, INFLATE);
|
||||
NODE_DEFINE_CONSTANT(target, GZIP);
|
||||
NODE_DEFINE_CONSTANT(target, GUNZIP);
|
||||
NODE_DEFINE_CONSTANT(target, DEFLATERAW);
|
||||
NODE_DEFINE_CONSTANT(target, INFLATERAW);
|
||||
NODE_DEFINE_CONSTANT(target, UNZIP);
|
||||
|
||||
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "ZLIB_VERSION"),
|
||||
FIXED_ONE_BYTE_STRING(env->isolate(), ZLIB_VERSION));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,9 +4,9 @@ var assert = require('assert');
|
|||
|
||||
var zlib = require('zlib');
|
||||
|
||||
assert.equal(zlib.Z_OK, 0, 'Z_OK should be 0');
|
||||
zlib.Z_OK = 1;
|
||||
assert.equal(zlib.Z_OK, 0, 'Z_OK should be 0');
|
||||
assert.equal(zlib.constants.Z_OK, 0, 'Z_OK should be 0');
|
||||
zlib.constants.Z_OK = 1;
|
||||
assert.equal(zlib.constants.Z_OK, 0, 'Z_OK should be 0');
|
||||
|
||||
assert.equal(zlib.codes.Z_OK, 0, 'Z_OK should be 0');
|
||||
zlib.codes.Z_OK = 1;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ const assert = require('assert');
|
|||
const zlib = require('zlib');
|
||||
|
||||
assert.doesNotThrow(() => {
|
||||
zlib.createGzip({ flush: zlib.Z_SYNC_FLUSH });
|
||||
zlib.createGzip({ flush: zlib.constants.Z_SYNC_FLUSH });
|
||||
});
|
||||
|
||||
assert.throws(() => {
|
||||
|
|
@ -16,7 +16,7 @@ assert.throws(() => {
|
|||
}, /Invalid flush flag: 10000/);
|
||||
|
||||
assert.doesNotThrow(() => {
|
||||
zlib.createGzip({ finishFlush: zlib.Z_SYNC_FLUSH });
|
||||
zlib.createGzip({ finishFlush: zlib.constants.Z_SYNC_FLUSH });
|
||||
});
|
||||
|
||||
assert.throws(() => {
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ let actualNone;
|
|||
let actualFull;
|
||||
|
||||
deflater.write(chunk, function() {
|
||||
deflater.flush(zlib.Z_NO_FLUSH, function() {
|
||||
deflater.flush(zlib.constants.Z_NO_FLUSH, function() {
|
||||
actualNone = deflater.read();
|
||||
deflater.flush(function() {
|
||||
var bufs = [], buf;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ var fs = require('fs');
|
|||
|
||||
const file = fs.readFileSync(path.resolve(common.fixturesDir, 'person.jpg'));
|
||||
const chunkSize = 12 * 1024;
|
||||
const opts = { level: 9, strategy: zlib.Z_DEFAULT_STRATEGY };
|
||||
const opts = { level: 9, strategy: zlib.constants.Z_DEFAULT_STRATEGY };
|
||||
const deflater = zlib.createDeflate(opts);
|
||||
|
||||
const chunk1 = file.slice(0, chunkSize);
|
||||
|
|
@ -17,7 +17,7 @@ const expected = Buffer.concat([blkhdr, chunk2]);
|
|||
let actual;
|
||||
|
||||
deflater.write(chunk1, function() {
|
||||
deflater.params(0, zlib.Z_DEFAULT_STRATEGY, function() {
|
||||
deflater.params(0, zlib.constants.Z_DEFAULT_STRATEGY, function() {
|
||||
while (deflater.read());
|
||||
deflater.end(chunk2, function() {
|
||||
var bufs = [], buf;
|
||||
|
|
|
|||
|
|
@ -11,11 +11,11 @@ const zipper = new zlib.Gzip();
|
|||
zipper.on('close', shouldNotBeCalled);
|
||||
|
||||
const buffer = new Buffer(message);
|
||||
const zipped = zipper._processChunk(buffer, zlib.Z_FINISH);
|
||||
const zipped = zipper._processChunk(buffer, zlib.constants.Z_FINISH);
|
||||
|
||||
const unzipper = new zlib.Gunzip();
|
||||
unzipper.on('close', shouldNotBeCalled);
|
||||
|
||||
const unzipped = unzipper._processChunk(zipped, zlib.Z_FINISH);
|
||||
const unzipped = unzipper._processChunk(zipped, zlib.constants.Z_FINISH);
|
||||
assert.notEqual(zipped.toString(), message);
|
||||
assert.strictEqual(unzipped.toString(), message);
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ const inputString = 'ΩΩLorem ipsum dolor sit amet, consectetur adipiscing eli'
|
|||
assert(/unexpected end of file/.test(err.message));
|
||||
});
|
||||
|
||||
const syncFlushOpt = { finishFlush: zlib.Z_SYNC_FLUSH };
|
||||
const syncFlushOpt = { finishFlush: zlib.constants.Z_SYNC_FLUSH };
|
||||
|
||||
// sync truncated input test, finishFlush = Z_SYNC_FLUSH
|
||||
assert.doesNotThrow(function() {
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ process.on('exit', function() {
|
|||
assert.equal(output, input);
|
||||
|
||||
// Make sure that the flush flag was set back to normal
|
||||
assert.equal(gzip._flushFlag, zlib.Z_NO_FLUSH);
|
||||
assert.equal(gzip._flushFlag, zlib.constants.Z_NO_FLUSH);
|
||||
|
||||
console.log('ok');
|
||||
});
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче