mirror of
https://github.com/nodejs/node.git
synced 2025-05-06 20:08:02 +00:00
e8734c034d
With V8 4.4 removing the external array data API currently used by Buffer, the new implementation uses the Uint8Array to back Buffer. Buffers now have a maximum size of Smi::kMaxLength, as defined by V8. Which is ~2 GB on 64 bit and ~1 GB on 32 bit. The flag --use-old-buffer allows using the old Buffer implementation. This flag will be removed once V8 4.4 has landed. The two JS Buffer implementations have been split into two files for simplicity. Use getter to return expected .parent/.offset values for backwards compatibility. PR-URL: https://github.com/nodejs/io.js/pull/1825 Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
1021 lines
23 KiB
JavaScript
1021 lines
23 KiB
JavaScript
'use strict';
|
|
|
|
const binding = process.binding('buffer');
|
|
const internalUtil = require('internal/util');
|
|
|
|
exports.Buffer = Buffer;
|
|
exports.SlowBuffer = SlowBuffer;
|
|
exports.INSPECT_MAX_BYTES = 50;
|
|
|
|
|
|
Buffer.poolSize = 8 * 1024;
|
|
var poolSize, poolOffset, allocPool;
|
|
|
|
|
|
function createPool() {
|
|
poolSize = Buffer.poolSize;
|
|
allocPool = binding.create(poolSize);
|
|
poolOffset = 0;
|
|
}
|
|
|
|
|
|
function Buffer(arg) {
|
|
// Common case.
|
|
if (typeof arg === 'number') {
|
|
// If less than zero, or NaN.
|
|
if (arg < 0 || arg !== arg)
|
|
arg = 0;
|
|
return allocate(arg);
|
|
}
|
|
|
|
// Slightly less common case.
|
|
if (typeof arg === 'string') {
|
|
return fromString(arg, arguments[1]);
|
|
}
|
|
|
|
// Unusual.
|
|
return fromObject(arg);
|
|
};
|
|
|
|
Buffer.prototype.__proto__ = Uint8Array.prototype;
|
|
Buffer.__proto__ = Uint8Array;
|
|
|
|
|
|
binding.setupBufferJS(Buffer.prototype);
|
|
// Buffer prototype must be past before creating our first pool.
|
|
createPool();
|
|
|
|
|
|
function SlowBuffer(length) {
|
|
if (length < 0)
|
|
length = 0;
|
|
return binding.create(length);
|
|
};
|
|
|
|
SlowBuffer.prototype.__proto__ = Buffer.prototype;
|
|
SlowBuffer.__proto__ = Buffer;
|
|
|
|
|
|
function allocate(size) {
|
|
if (size === 0)
|
|
return binding.create(0);
|
|
if (size < (Buffer.poolSize >>> 1)) {
|
|
if (size > (poolSize - poolOffset))
|
|
createPool();
|
|
var b = binding.slice(allocPool, poolOffset, poolOffset + size);
|
|
poolOffset += size;
|
|
return b;
|
|
} else {
|
|
return binding.create(size);
|
|
}
|
|
}
|
|
|
|
|
|
function fromString(string, encoding) {
|
|
if (typeof encoding !== 'string' || encoding === '')
|
|
encoding = 'utf8';
|
|
|
|
var length = byteLength(string, encoding);
|
|
if (length >= (Buffer.poolSize >>> 1))
|
|
return binding.createFromString(string, encoding);
|
|
|
|
if (length > (poolSize - poolOffset))
|
|
createPool();
|
|
var actual = allocPool.write(string, poolOffset, encoding);
|
|
var b = binding.slice(allocPool, poolOffset, poolOffset + actual);
|
|
poolOffset += actual;
|
|
return b;
|
|
}
|
|
|
|
|
|
function fromObject(obj) {
|
|
if (obj instanceof Buffer) {
|
|
var b = allocate(obj.length);
|
|
obj.copy(b, 0, 0, obj.length);
|
|
return b;
|
|
}
|
|
|
|
if (Array.isArray(obj)) {
|
|
var length = obj.length;
|
|
var b = allocate(length);
|
|
for (var i = 0; i < length; i++)
|
|
b[i] = obj[i] & 255;
|
|
return b;
|
|
}
|
|
|
|
// TODO(trevnorris): This will fail for an actual ArrayBuffer.
|
|
if (obj.buffer instanceof ArrayBuffer || obj.length) {
|
|
var length;
|
|
if (typeof obj.length !== 'number' || obj.length !== obj.length)
|
|
length = 0;
|
|
else
|
|
length = obj.length;
|
|
var b = allocate(length);
|
|
for (var i = 0; i < length; i++) {
|
|
b[i] = obj[i] & 255;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
|
|
var array = obj.data;
|
|
var b = allocate(array.length);
|
|
for (var i = 0; i < array.length; i++)
|
|
b[i] = array[i] & 255;
|
|
return b;
|
|
}
|
|
|
|
throw new TypeError('must start with number, buffer, array or string');
|
|
}
|
|
|
|
|
|
// Static methods
|
|
|
|
Buffer.isBuffer = function isBuffer(b) {
|
|
return b instanceof Buffer;
|
|
};
|
|
|
|
|
|
Buffer.compare = function compare(a, b) {
|
|
if (!(a instanceof Buffer) ||
|
|
!(b instanceof Buffer)) {
|
|
throw new TypeError('Arguments must be Buffers');
|
|
}
|
|
|
|
if (a === b) {
|
|
return 0;
|
|
}
|
|
|
|
return binding.compare(a, b);
|
|
};
|
|
|
|
|
|
Buffer.isEncoding = function(encoding) {
|
|
var loweredCase = false;
|
|
for (;;) {
|
|
switch (encoding) {
|
|
case 'hex':
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case 'ascii':
|
|
case 'binary':
|
|
case 'base64':
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
case 'raw':
|
|
return true;
|
|
|
|
default:
|
|
if (loweredCase)
|
|
return false;
|
|
encoding = ('' + encoding).toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
Buffer.concat = function(list, length) {
|
|
if (!Array.isArray(list))
|
|
throw new TypeError('list argument must be an Array of Buffers.');
|
|
|
|
if (list.length === 0)
|
|
return new Buffer(0);
|
|
else if (list.length === 1)
|
|
return list[0];
|
|
|
|
if (length === undefined) {
|
|
length = 0;
|
|
for (var i = 0; i < list.length; i++)
|
|
length += list[i].length;
|
|
} else {
|
|
length = length >>> 0;
|
|
}
|
|
|
|
var buffer = new Buffer(length);
|
|
var pos = 0;
|
|
for (var i = 0; i < list.length; i++) {
|
|
var buf = list[i];
|
|
buf.copy(buffer, pos);
|
|
pos += buf.length;
|
|
}
|
|
|
|
return buffer;
|
|
};
|
|
|
|
|
|
function base64ByteLength(str, bytes) {
|
|
// Handle padding
|
|
if (str.charCodeAt(bytes - 1) === 0x3D)
|
|
bytes--;
|
|
if (bytes > 1 && str.charCodeAt(bytes - 1) === 0x3D)
|
|
bytes--;
|
|
|
|
// Base64 ratio: 3/4
|
|
return (bytes * 3) >>> 2;
|
|
}
|
|
|
|
|
|
function byteLength(string, encoding) {
|
|
if (typeof string !== 'string')
|
|
string = '' + string;
|
|
|
|
var len = string.length;
|
|
if (len === 0)
|
|
return 0;
|
|
|
|
// Use a for loop to avoid recursion
|
|
var loweredCase = false;
|
|
for (;;) {
|
|
switch (encoding) {
|
|
case 'ascii':
|
|
case 'binary':
|
|
// Deprecated
|
|
case 'raw':
|
|
case 'raws':
|
|
return len;
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return binding.byteLengthUtf8(string);
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return len * 2;
|
|
|
|
case 'hex':
|
|
return len >>> 1;
|
|
|
|
case 'base64':
|
|
return base64ByteLength(string, len);
|
|
|
|
default:
|
|
// The C++ binding defaulted to UTF8, we should too.
|
|
if (loweredCase)
|
|
return binding.byteLengthUtf8(string);
|
|
|
|
encoding = ('' + encoding).toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
Buffer.byteLength = byteLength;
|
|
|
|
|
|
// For backwards compatibility.
|
|
Object.defineProperty(Buffer.prototype, 'parent', {
|
|
enumerable: true,
|
|
get: function() {
|
|
if (this.byteLength === 0 ||
|
|
this.byteLength === this.buffer.byteLength) {
|
|
return undefined;
|
|
}
|
|
return this.buffer;
|
|
}
|
|
});
|
|
Object.defineProperty(Buffer.prototype, 'offset', {
|
|
enumerable: true,
|
|
get: function() {
|
|
return this.byteOffset;
|
|
}
|
|
});
|
|
|
|
|
|
// toString(encoding, start=0, end=buffer.length)
|
|
Buffer.prototype.toString = function(encoding, start, end) {
|
|
var loweredCase = false;
|
|
|
|
start = start >>> 0;
|
|
end = end === undefined || end === Infinity ? this.length : end >>> 0;
|
|
|
|
if (!encoding) encoding = 'utf8';
|
|
if (start < 0) start = 0;
|
|
if (end > this.length) end = this.length;
|
|
if (end <= start) return '';
|
|
|
|
while (true) {
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return this.hexSlice(start, end);
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return this.utf8Slice(start, end);
|
|
|
|
case 'ascii':
|
|
return this.asciiSlice(start, end);
|
|
|
|
case 'binary':
|
|
return this.binarySlice(start, end);
|
|
|
|
case 'base64':
|
|
return this.base64Slice(start, end);
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return this.ucs2Slice(start, end);
|
|
|
|
default:
|
|
if (loweredCase)
|
|
throw new TypeError('Unknown encoding: ' + encoding);
|
|
encoding = (encoding + '').toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
Buffer.prototype.equals = function equals(b) {
|
|
if (!(b instanceof Buffer))
|
|
throw new TypeError('Argument must be a Buffer');
|
|
|
|
if (this === b)
|
|
return true;
|
|
|
|
return binding.compare(this, b) === 0;
|
|
};
|
|
|
|
|
|
// Inspect
|
|
Buffer.prototype.inspect = function inspect() {
|
|
var str = '';
|
|
var max = exports.INSPECT_MAX_BYTES;
|
|
if (this.length > 0) {
|
|
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
|
|
if (this.length > max)
|
|
str += ' ... ';
|
|
}
|
|
return '<' + this.constructor.name + ' ' + str + '>';
|
|
};
|
|
|
|
|
|
Buffer.prototype.compare = function compare(b) {
|
|
if (!(b instanceof Buffer))
|
|
throw new TypeError('Argument must be a Buffer');
|
|
|
|
if (this === b)
|
|
return 0;
|
|
|
|
return binding.compare(this, b);
|
|
};
|
|
|
|
|
|
Buffer.prototype.indexOf = function indexOf(val, byteOffset) {
|
|
if (byteOffset > 0x7fffffff)
|
|
byteOffset = 0x7fffffff;
|
|
else if (byteOffset < -0x80000000)
|
|
byteOffset = -0x80000000;
|
|
byteOffset >>= 0;
|
|
|
|
if (typeof val === 'string')
|
|
return binding.indexOfString(this, val, byteOffset);
|
|
if (val instanceof Buffer)
|
|
return binding.indexOfBuffer(this, val, byteOffset);
|
|
if (typeof val === 'number')
|
|
return binding.indexOfNumber(this, val, byteOffset);
|
|
|
|
throw new TypeError('val must be string, number or Buffer');
|
|
};
|
|
|
|
|
|
Buffer.prototype.fill = function fill(val, start, end) {
|
|
start = start >> 0;
|
|
end = (end === undefined) ? this.length : end >> 0;
|
|
|
|
if (start < 0 || end > this.length)
|
|
throw new RangeError('out of range index');
|
|
if (end <= start)
|
|
return this;
|
|
|
|
if (typeof val !== 'string') {
|
|
val = val >>> 0;
|
|
} else if (val.length === 1) {
|
|
var code = val.charCodeAt(0);
|
|
if (code < 256)
|
|
val = code;
|
|
}
|
|
|
|
binding.fill(this, val, start, end);
|
|
|
|
return this;
|
|
};
|
|
|
|
|
|
// XXX remove in v0.13
|
|
Buffer.prototype.get = internalUtil.deprecate(function get(offset) {
|
|
offset = ~~offset;
|
|
if (offset < 0 || offset >= this.length)
|
|
throw new RangeError('index out of range');
|
|
return this[offset];
|
|
}, '.get() is deprecated. Access using array indexes instead.');
|
|
|
|
|
|
// XXX remove in v0.13
|
|
Buffer.prototype.set = internalUtil.deprecate(function set(offset, v) {
|
|
offset = ~~offset;
|
|
if (offset < 0 || offset >= this.length)
|
|
throw new RangeError('index out of range');
|
|
return this[offset] = v;
|
|
}, '.set() is deprecated. Set using array indexes instead.');
|
|
|
|
|
|
// TODO(trevnorris): fix these checks to follow new standard
|
|
// write(string, offset = 0, length = buffer.length, encoding = 'utf8')
|
|
var writeWarned = false;
|
|
const writeMsg = '.write(string, encoding, offset, length) is deprecated.' +
|
|
' Use write(string[, offset[, length]][, encoding]) instead.';
|
|
Buffer.prototype.write = function(string, offset, length, encoding) {
|
|
// Buffer#write(string);
|
|
if (offset === undefined) {
|
|
encoding = 'utf8';
|
|
length = this.length;
|
|
offset = 0;
|
|
|
|
// Buffer#write(string, encoding)
|
|
} else if (length === undefined && typeof offset === 'string') {
|
|
encoding = offset;
|
|
length = this.length;
|
|
offset = 0;
|
|
|
|
// Buffer#write(string, offset[, length][, encoding])
|
|
} else if (isFinite(offset)) {
|
|
offset = offset >>> 0;
|
|
if (isFinite(length)) {
|
|
length = length >>> 0;
|
|
if (encoding === undefined)
|
|
encoding = 'utf8';
|
|
} else {
|
|
encoding = length;
|
|
length = undefined;
|
|
}
|
|
|
|
// XXX legacy write(string, encoding, offset, length) - remove in v0.13
|
|
} else {
|
|
if (!writeWarned) {
|
|
if (process.throwDeprecation)
|
|
throw new Error(writeMsg);
|
|
else if (process.traceDeprecation)
|
|
console.trace(writeMsg);
|
|
else
|
|
console.error(writeMsg);
|
|
writeWarned = true;
|
|
}
|
|
|
|
var swap = encoding;
|
|
encoding = offset;
|
|
offset = length >>> 0;
|
|
length = swap;
|
|
}
|
|
|
|
var remaining = this.length - offset;
|
|
if (length === undefined || length > remaining)
|
|
length = remaining;
|
|
|
|
if (string.length > 0 && (length < 0 || offset < 0))
|
|
throw new RangeError('attempt to write outside buffer bounds');
|
|
|
|
if (!encoding)
|
|
encoding = 'utf8';
|
|
|
|
var loweredCase = false;
|
|
for (;;) {
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return this.hexWrite(string, offset, length);
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return this.utf8Write(string, offset, length);
|
|
|
|
case 'ascii':
|
|
return this.asciiWrite(string, offset, length);
|
|
|
|
case 'binary':
|
|
return this.binaryWrite(string, offset, length);
|
|
|
|
case 'base64':
|
|
// Warning: maxLength not taken into account in base64Write
|
|
return this.base64Write(string, offset, length);
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return this.ucs2Write(string, offset, length);
|
|
|
|
default:
|
|
if (loweredCase)
|
|
throw new TypeError('Unknown encoding: ' + encoding);
|
|
encoding = ('' + encoding).toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
Buffer.prototype.toJSON = function() {
|
|
return {
|
|
type: 'Buffer',
|
|
data: Array.prototype.slice.call(this, 0)
|
|
};
|
|
};
|
|
|
|
|
|
// TODO(trevnorris): currently works like Array.prototype.slice(), which
|
|
// doesn't follow the new standard for throwing on out of range indexes.
|
|
Buffer.prototype.slice = function slice(start, end) {
|
|
var len = this.length;
|
|
start = ~~start;
|
|
end = end === undefined ? len : ~~end;
|
|
|
|
if (start < 0) {
|
|
start += len;
|
|
if (start < 0)
|
|
start = 0;
|
|
} else if (start > len) {
|
|
start = len;
|
|
}
|
|
|
|
if (end < 0) {
|
|
end += len;
|
|
if (end < 0)
|
|
end = 0;
|
|
} else if (end > len) {
|
|
end = len;
|
|
}
|
|
|
|
if (end < start)
|
|
end = start;
|
|
|
|
return binding.slice(this, start, end);
|
|
};
|
|
|
|
|
|
function checkOffset(offset, ext, length) {
|
|
if (offset + ext > length)
|
|
throw new RangeError('index out of range');
|
|
}
|
|
|
|
|
|
Buffer.prototype.readUIntLE = function(offset, byteLength, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength = byteLength >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength, this.length);
|
|
|
|
var val = this[offset];
|
|
var mul = 1;
|
|
var i = 0;
|
|
while (++i < byteLength && (mul *= 0x100))
|
|
val += this[offset + i] * mul;
|
|
|
|
return val;
|
|
};
|
|
|
|
|
|
Buffer.prototype.readUIntBE = function(offset, byteLength, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength = byteLength >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength, this.length);
|
|
|
|
var val = this[offset + --byteLength];
|
|
var mul = 1;
|
|
while (byteLength > 0 && (mul *= 0x100))
|
|
val += this[offset + --byteLength] * mul;
|
|
|
|
return val;
|
|
};
|
|
|
|
|
|
Buffer.prototype.readUInt8 = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 1, this.length);
|
|
return this[offset];
|
|
};
|
|
|
|
|
|
Buffer.prototype.readUInt16LE = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
return this[offset] | (this[offset + 1] << 8);
|
|
};
|
|
|
|
|
|
Buffer.prototype.readUInt16BE = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
return (this[offset] << 8) | this[offset + 1];
|
|
};
|
|
|
|
|
|
Buffer.prototype.readUInt32LE = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
|
|
return ((this[offset]) |
|
|
(this[offset + 1] << 8) |
|
|
(this[offset + 2] << 16)) +
|
|
(this[offset + 3] * 0x1000000);
|
|
};
|
|
|
|
|
|
Buffer.prototype.readUInt32BE = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
|
|
return (this[offset] * 0x1000000) +
|
|
((this[offset + 1] << 16) |
|
|
(this[offset + 2] << 8) |
|
|
this[offset + 3]);
|
|
};
|
|
|
|
|
|
Buffer.prototype.readIntLE = function(offset, byteLength, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength = byteLength >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength, this.length);
|
|
|
|
var val = this[offset];
|
|
var mul = 1;
|
|
var i = 0;
|
|
while (++i < byteLength && (mul *= 0x100))
|
|
val += this[offset + i] * mul;
|
|
mul *= 0x80;
|
|
|
|
if (val >= mul)
|
|
val -= Math.pow(2, 8 * byteLength);
|
|
|
|
return val;
|
|
};
|
|
|
|
|
|
Buffer.prototype.readIntBE = function(offset, byteLength, noAssert) {
|
|
offset = offset >>> 0;
|
|
byteLength = byteLength >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, byteLength, this.length);
|
|
|
|
var i = byteLength;
|
|
var mul = 1;
|
|
var val = this[offset + --i];
|
|
while (i > 0 && (mul *= 0x100))
|
|
val += this[offset + --i] * mul;
|
|
mul *= 0x80;
|
|
|
|
if (val >= mul)
|
|
val -= Math.pow(2, 8 * byteLength);
|
|
|
|
return val;
|
|
};
|
|
|
|
|
|
Buffer.prototype.readInt8 = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 1, this.length);
|
|
var val = this[offset];
|
|
return !(val & 0x80) ? val : (0xff - val + 1) * -1;
|
|
};
|
|
|
|
|
|
Buffer.prototype.readInt16LE = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
var val = this[offset] | (this[offset + 1] << 8);
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val;
|
|
};
|
|
|
|
|
|
Buffer.prototype.readInt16BE = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 2, this.length);
|
|
var val = this[offset + 1] | (this[offset] << 8);
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val;
|
|
};
|
|
|
|
|
|
Buffer.prototype.readInt32LE = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
|
|
return (this[offset]) |
|
|
(this[offset + 1] << 8) |
|
|
(this[offset + 2] << 16) |
|
|
(this[offset + 3] << 24);
|
|
};
|
|
|
|
|
|
Buffer.prototype.readInt32BE = function(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
|
|
return (this[offset] << 24) |
|
|
(this[offset + 1] << 16) |
|
|
(this[offset + 2] << 8) |
|
|
(this[offset + 3]);
|
|
};
|
|
|
|
|
|
Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return binding.readFloatLE(this, offset);
|
|
};
|
|
|
|
|
|
Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 4, this.length);
|
|
return binding.readFloatBE(this, offset);
|
|
};
|
|
|
|
|
|
Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 8, this.length);
|
|
return binding.readDoubleLE(this, offset);
|
|
};
|
|
|
|
|
|
Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkOffset(offset, 8, this.length);
|
|
return binding.readDoubleBE(this, offset);
|
|
};
|
|
|
|
|
|
function checkInt(buffer, value, offset, ext, max, min) {
|
|
if (!(buffer instanceof Buffer))
|
|
throw new TypeError('buffer must be a Buffer instance');
|
|
if (value > max || value < min)
|
|
throw new TypeError('value is out of bounds');
|
|
if (offset + ext > buffer.length)
|
|
throw new RangeError('index out of range');
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeUIntLE = function(value, offset, byteLength, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
byteLength = byteLength >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0);
|
|
|
|
var mul = 1;
|
|
var i = 0;
|
|
this[offset] = value;
|
|
while (++i < byteLength && (mul *= 0x100))
|
|
this[offset + i] = (value / mul) >>> 0;
|
|
|
|
return offset + byteLength;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeUIntBE = function(value, offset, byteLength, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
byteLength = byteLength >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0);
|
|
|
|
var i = byteLength - 1;
|
|
var mul = 1;
|
|
this[offset + i] = value;
|
|
while (--i >= 0 && (mul *= 0x100))
|
|
this[offset + i] = (value / mul) >>> 0;
|
|
|
|
return offset + byteLength;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeUInt8 = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 1, 0xff, 0);
|
|
this[offset] = value;
|
|
return offset + 1;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeUInt16LE = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 0xffff, 0);
|
|
this[offset] = value;
|
|
this[offset + 1] = (value >>> 8);
|
|
return offset + 2;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 0xffff, 0);
|
|
this[offset] = (value >>> 8);
|
|
this[offset + 1] = value;
|
|
return offset + 2;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 0xffffffff, 0);
|
|
this[offset + 3] = (value >>> 24);
|
|
this[offset + 2] = (value >>> 16);
|
|
this[offset + 1] = (value >>> 8);
|
|
this[offset] = value;
|
|
return offset + 4;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 0xffffffff, 0);
|
|
this[offset] = (value >>> 24);
|
|
this[offset + 1] = (value >>> 16);
|
|
this[offset + 2] = (value >>> 8);
|
|
this[offset + 3] = value;
|
|
return offset + 4;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeIntLE = function(value, offset, byteLength, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
checkInt(this,
|
|
value,
|
|
offset,
|
|
byteLength,
|
|
Math.pow(2, 8 * byteLength - 1) - 1,
|
|
-Math.pow(2, 8 * byteLength - 1));
|
|
}
|
|
|
|
var i = 0;
|
|
var mul = 1;
|
|
var sub = value < 0 ? 1 : 0;
|
|
this[offset] = value;
|
|
while (++i < byteLength && (mul *= 0x100))
|
|
this[offset + i] = ((value / mul) >> 0) - sub;
|
|
|
|
return offset + byteLength;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeIntBE = function(value, offset, byteLength, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert) {
|
|
checkInt(this,
|
|
value,
|
|
offset,
|
|
byteLength,
|
|
Math.pow(2, 8 * byteLength - 1) - 1,
|
|
-Math.pow(2, 8 * byteLength - 1));
|
|
}
|
|
|
|
var i = byteLength - 1;
|
|
var mul = 1;
|
|
var sub = value < 0 ? 1 : 0;
|
|
this[offset + i] = value;
|
|
while (--i >= 0 && (mul *= 0x100))
|
|
this[offset + i] = ((value / mul) >> 0) - sub;
|
|
|
|
return offset + byteLength;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeInt8 = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 1, 0x7f, -0x80);
|
|
this[offset] = value;
|
|
return offset + 1;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeInt16LE = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 0x7fff, -0x8000);
|
|
this[offset] = value;
|
|
this[offset + 1] = (value >>> 8);
|
|
return offset + 2;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeInt16BE = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 2, 0x7fff, -0x8000);
|
|
this[offset] = (value >>> 8);
|
|
this[offset + 1] = value;
|
|
return offset + 2;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeInt32LE = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
|
|
this[offset] = value;
|
|
this[offset + 1] = (value >>> 8);
|
|
this[offset + 2] = (value >>> 16);
|
|
this[offset + 3] = (value >>> 24);
|
|
return offset + 4;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeInt32BE = function(value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
|
|
this[offset] = (value >>> 24);
|
|
this[offset + 1] = (value >>> 16);
|
|
this[offset + 2] = (value >>> 8);
|
|
this[offset + 3] = value;
|
|
return offset + 4;
|
|
};
|
|
|
|
|
|
function checkFloat(buffer, value, offset, ext) {
|
|
if (!(buffer instanceof Buffer))
|
|
throw new TypeError('buffer must be a Buffer instance');
|
|
if (offset + ext > buffer.length)
|
|
throw new RangeError('index out of range');
|
|
}
|
|
|
|
|
|
Buffer.prototype.writeFloatLE = function writeFloatLE(val, offset, noAssert) {
|
|
val = +val;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkFloat(this, val, offset, 4);
|
|
binding.writeFloatLE(this, val, offset);
|
|
return offset + 4;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeFloatBE = function writeFloatBE(val, offset, noAssert) {
|
|
val = +val;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkFloat(this, val, offset, 4);
|
|
binding.writeFloatBE(this, val, offset);
|
|
return offset + 4;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeDoubleLE = function writeDoubleLE(val, offset, noAssert) {
|
|
val = +val;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkFloat(this, val, offset, 8);
|
|
binding.writeDoubleLE(this, val, offset);
|
|
return offset + 8;
|
|
};
|
|
|
|
|
|
Buffer.prototype.writeDoubleBE = function writeDoubleBE(val, offset, noAssert) {
|
|
val = +val;
|
|
offset = offset >>> 0;
|
|
if (!noAssert)
|
|
checkFloat(this, val, offset, 8);
|
|
binding.writeDoubleBE(this, val, offset);
|
|
return offset + 8;
|
|
};
|