mirror of
https://github.com/nodejs/node.git
synced 2024-11-25 08:19:38 +01:00
60a974d200
The new implementation of Buffer missed the check for null/undefined as
the first argument to new Buffer(). Reintroduce the check and add test.
Fix: e8734c0 "buffer: implement Uint8Array backed Buffer"
Fix: https://github.com/nodejs/io.js/issues/2194
PR-URL: https://github.com/nodejs/io.js/pull/2195
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Rod Vagg <rod@vagg.org>
1027 lines
24 KiB
JavaScript
1027 lines
24 KiB
JavaScript
/* eslint-disable require-buffer */
|
|
'use strict';
|
|
|
|
const binding = process.binding('buffer');
|
|
const internalUtil = require('internal/util');
|
|
|
|
exports.Buffer = Buffer;
|
|
exports.SlowBuffer = SlowBuffer;
|
|
exports.INSPECT_MAX_BYTES = 50;
|
|
exports.kMaxLength = binding.kMaxLength;
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
if (obj == null) {
|
|
throw new TypeError('must start with number, buffer, array or string');
|
|
}
|
|
|
|
if (obj instanceof ArrayBuffer) {
|
|
return binding.createFromArrayBuffer(obj);
|
|
}
|
|
|
|
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);
|
|
|
|
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;
|
|
}
|
|
});
|
|
|
|
|
|
function slowToString(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.toString = function() {
|
|
const length = this.length | 0;
|
|
if (arguments.length === 0)
|
|
return this.utf8Slice(0, length);
|
|
return slowToString.apply(this, arguments);
|
|
};
|
|
|
|
|
|
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];
|
|
}, 'Buffer.get is deprecated. Use 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;
|
|
}, 'Buffer.set is deprecated. Use 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 = 'Buffer.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 {
|
|
writeWarned = internalUtil.printDeprecationMessage(writeMsg, writeWarned);
|
|
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;
|
|
};
|