You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
473 lines
16 KiB
473 lines
16 KiB
5 years ago
|
'use strict';
|
||
|
|
||
|
var assert = require("assert");
|
||
|
|
||
|
// JavaScript is numerically challenged
|
||
|
var SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
|
||
|
var SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
|
||
|
|
||
|
// The maximum contiguous integer that can be held in a IEEE754 double
|
||
|
var MAX_INT = 0x1fffffffffffff;
|
||
|
|
||
|
function isContiguousInt(val) {
|
||
|
return val <= MAX_INT && val >= -MAX_INT;
|
||
|
}
|
||
|
|
||
|
function assertContiguousInt(val) {
|
||
|
assert(isContiguousInt(val), "number cannot be represented as a contiguous integer");
|
||
|
}
|
||
|
|
||
|
module.exports.isContiguousInt = isContiguousInt;
|
||
|
module.exports.assertContiguousInt = assertContiguousInt;
|
||
|
|
||
|
// Fill in the regular procedures
|
||
|
['UInt', 'Int'].forEach(function (sign) {
|
||
|
var suffix = sign + '8';
|
||
|
module.exports['read' + suffix] =
|
||
|
Buffer.prototype['read' + suffix].call;
|
||
|
module.exports['write' + suffix] =
|
||
|
Buffer.prototype['write' + suffix].call;
|
||
|
|
||
|
['16', '32'].forEach(function (size) {
|
||
|
['LE', 'BE'].forEach(function (endian) {
|
||
|
var suffix = sign + size + endian;
|
||
|
var read = Buffer.prototype['read' + suffix];
|
||
|
module.exports['read' + suffix] =
|
||
|
function (buf, offset, noAssert) {
|
||
|
return read.call(buf, offset, noAssert);
|
||
|
};
|
||
|
var write = Buffer.prototype['write' + suffix];
|
||
|
module.exports['write' + suffix] =
|
||
|
function (buf, val, offset, noAssert) {
|
||
|
return write.call(buf, val, offset, noAssert);
|
||
|
};
|
||
|
});
|
||
|
});
|
||
|
});
|
||
|
|
||
|
// Check that a value is an integer within the given range
|
||
|
function check_int(val, min, max) {
|
||
|
assert.ok(typeof(val) == 'number' && val >= min && val <= max && Math.floor(val) === val, "not a number in the required range");
|
||
|
}
|
||
|
|
||
|
function readUInt24BE(buf, offset, noAssert) {
|
||
|
return buf.readUInt8(offset, noAssert) << 16 | buf.readUInt16BE(offset + 1, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt24BE = readUInt24BE;
|
||
|
|
||
|
function writeUInt24BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffff);
|
||
|
assert.ok(offset + 3 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeUInt8(val >>> 16, offset, noAssert);
|
||
|
buf.writeUInt16BE(val & 0xffff, offset + 1, noAssert);
|
||
|
}
|
||
|
module.exports.writeUInt24BE = writeUInt24BE;
|
||
|
|
||
|
function readUInt40BE(buf, offset, noAssert) {
|
||
|
return (buf.readUInt8(offset, noAssert) || 0) * SHIFT_LEFT_32 + buf.readUInt32BE(offset + 1, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt40BE = readUInt40BE;
|
||
|
|
||
|
function writeUInt40BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffffffff);
|
||
|
assert.ok(offset + 5 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeUInt8(Math.floor(val * SHIFT_RIGHT_32), offset, noAssert);
|
||
|
buf.writeInt32BE(val & -1, offset + 1, noAssert);
|
||
|
}
|
||
|
module.exports.writeUInt40BE = writeUInt40BE;
|
||
|
|
||
|
function readUInt48BE(buf, offset, noAssert) {
|
||
|
return buf.readUInt16BE(offset, noAssert) * SHIFT_LEFT_32 + buf.readUInt32BE(offset + 2, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt48BE = readUInt48BE;
|
||
|
|
||
|
function writeUInt48BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffffffffff);
|
||
|
assert.ok(offset + 6 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeUInt16BE(Math.floor(val * SHIFT_RIGHT_32), offset, noAssert);
|
||
|
buf.writeInt32BE(val & -1, offset + 2, noAssert);
|
||
|
}
|
||
|
module.exports.writeUInt48BE = writeUInt48BE;
|
||
|
|
||
|
function readUInt56BE(buf, offset, noAssert) {
|
||
|
return ((buf.readUInt8(offset, noAssert) || 0) << 16 | buf.readUInt16BE(offset + 1, noAssert)) * SHIFT_LEFT_32 + buf.readUInt32BE(offset + 3, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt56BE = readUInt56BE;
|
||
|
|
||
|
function writeUInt56BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffffffffffff);
|
||
|
assert.ok(offset + 7 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
if (val < 0x100000000000000) {
|
||
|
var hi = Math.floor(val * SHIFT_RIGHT_32);
|
||
|
buf.writeUInt8(hi >>> 16, offset, noAssert);
|
||
|
buf.writeUInt16BE(hi & 0xffff, offset + 1, noAssert);
|
||
|
buf.writeInt32BE(val & -1, offset + 3, noAssert);
|
||
|
} else {
|
||
|
// Special case because 2^56-1 gets rounded up to 2^56
|
||
|
buf[offset] = 0xff;
|
||
|
buf[offset+1] = 0xff;
|
||
|
buf[offset+2] = 0xff;
|
||
|
buf[offset+3] = 0xff;
|
||
|
buf[offset+4] = 0xff;
|
||
|
buf[offset+5] = 0xff;
|
||
|
buf[offset+6] = 0xff;
|
||
|
}
|
||
|
}
|
||
|
module.exports.writeUInt56BE = writeUInt56BE;
|
||
|
|
||
|
function readUInt64BE(buf, offset, noAssert) {
|
||
|
return buf.readUInt32BE(offset, noAssert) * SHIFT_LEFT_32 + buf.readUInt32BE(offset + 4, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt64BE = readUInt64BE;
|
||
|
|
||
|
function writeUInt64BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffffffffffffff);
|
||
|
assert.ok(offset + 8 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
if (val < 0x10000000000000000) {
|
||
|
buf.writeUInt32BE(Math.floor(val * SHIFT_RIGHT_32), offset, noAssert);
|
||
|
buf.writeInt32BE(val & -1, offset + 4, noAssert);
|
||
|
} else {
|
||
|
// Special case because 2^64-1 gets rounded up to 2^64
|
||
|
buf[offset] = 0xff;
|
||
|
buf[offset+1] = 0xff;
|
||
|
buf[offset+2] = 0xff;
|
||
|
buf[offset+3] = 0xff;
|
||
|
buf[offset+4] = 0xff;
|
||
|
buf[offset+5] = 0xff;
|
||
|
buf[offset+6] = 0xff;
|
||
|
buf[offset+7] = 0xff;
|
||
|
}
|
||
|
}
|
||
|
module.exports.writeUInt64BE = writeUInt64BE;
|
||
|
|
||
|
function readUInt24LE(buf, offset, noAssert) {
|
||
|
return buf.readUInt8(offset + 2, noAssert) << 16 | buf.readUInt16LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt24LE = readUInt24LE;
|
||
|
|
||
|
function writeUInt24LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffff);
|
||
|
assert.ok(offset + 3 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeUInt16LE(val & 0xffff, offset, noAssert);
|
||
|
buf.writeUInt8(val >>> 16, offset + 2, noAssert);
|
||
|
}
|
||
|
module.exports.writeUInt24LE = writeUInt24LE;
|
||
|
|
||
|
function readUInt40LE(buf, offset, noAssert) {
|
||
|
return (buf.readUInt8(offset + 4, noAssert) || 0) * SHIFT_LEFT_32 + buf.readUInt32LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt40LE = readUInt40LE;
|
||
|
|
||
|
function writeUInt40LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffffffff);
|
||
|
assert.ok(offset + 5 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeInt32LE(val & -1, offset, noAssert);
|
||
|
buf.writeUInt8(Math.floor(val * SHIFT_RIGHT_32), offset + 4, noAssert);
|
||
|
}
|
||
|
module.exports.writeUInt40LE = writeUInt40LE;
|
||
|
|
||
|
function readUInt48LE(buf, offset, noAssert) {
|
||
|
return buf.readUInt16LE(offset + 4, noAssert) * SHIFT_LEFT_32 + buf.readUInt32LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt48LE = readUInt48LE;
|
||
|
|
||
|
function writeUInt48LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffffffffff);
|
||
|
assert.ok(offset + 6 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeInt32LE(val & -1, offset, noAssert);
|
||
|
buf.writeUInt16LE(Math.floor(val * SHIFT_RIGHT_32), offset + 4, noAssert);
|
||
|
}
|
||
|
module.exports.writeUInt48LE = writeUInt48LE;
|
||
|
|
||
|
function readUInt56LE(buf, offset, noAssert) {
|
||
|
return ((buf.readUInt8(offset + 6, noAssert) || 0) << 16 | buf.readUInt16LE(offset + 4, noAssert)) * SHIFT_LEFT_32 + buf.readUInt32LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt56LE = readUInt56LE;
|
||
|
|
||
|
function writeUInt56LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffffffffffff);
|
||
|
assert.ok(offset + 7 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
if (val < 0x100000000000000) {
|
||
|
buf.writeInt32LE(val & -1, offset, noAssert);
|
||
|
var hi = Math.floor(val * SHIFT_RIGHT_32);
|
||
|
buf.writeUInt16LE(hi & 0xffff, offset + 4, noAssert);
|
||
|
buf.writeUInt8(hi >>> 16, offset + 6, noAssert);
|
||
|
} else {
|
||
|
// Special case because 2^56-1 gets rounded up to 2^56
|
||
|
buf[offset] = 0xff;
|
||
|
buf[offset+1] = 0xff;
|
||
|
buf[offset+2] = 0xff;
|
||
|
buf[offset+3] = 0xff;
|
||
|
buf[offset+4] = 0xff;
|
||
|
buf[offset+5] = 0xff;
|
||
|
buf[offset+6] = 0xff;
|
||
|
}
|
||
|
}
|
||
|
module.exports.writeUInt56LE = writeUInt56LE;
|
||
|
|
||
|
function readUInt64LE(buf, offset, noAssert) {
|
||
|
return buf.readUInt32LE(offset + 4, noAssert) * SHIFT_LEFT_32 + buf.readUInt32LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readUInt64LE = readUInt64LE;
|
||
|
|
||
|
function writeUInt64LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, 0, 0xffffffffffffffff);
|
||
|
assert.ok(offset + 8 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
if (val < 0x10000000000000000) {
|
||
|
buf.writeInt32LE(val & -1, offset, noAssert);
|
||
|
buf.writeUInt32LE(Math.floor(val * SHIFT_RIGHT_32), offset + 4, noAssert);
|
||
|
} else {
|
||
|
// Special case because 2^64-1 gets rounded up to 2^64
|
||
|
buf[offset] = 0xff;
|
||
|
buf[offset+1] = 0xff;
|
||
|
buf[offset+2] = 0xff;
|
||
|
buf[offset+3] = 0xff;
|
||
|
buf[offset+4] = 0xff;
|
||
|
buf[offset+5] = 0xff;
|
||
|
buf[offset+6] = 0xff;
|
||
|
buf[offset+7] = 0xff;
|
||
|
}
|
||
|
}
|
||
|
module.exports.writeUInt64LE = writeUInt64LE;
|
||
|
|
||
|
|
||
|
function readInt24BE(buf, offset, noAssert) {
|
||
|
return (buf.readInt8(offset, noAssert) << 16) + buf.readUInt16BE(offset + 1, noAssert);
|
||
|
}
|
||
|
module.exports.readInt24BE = readInt24BE;
|
||
|
|
||
|
function writeInt24BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x800000, 0x7fffff);
|
||
|
assert.ok(offset + 3 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeInt8(val >> 16, offset, noAssert);
|
||
|
buf.writeUInt16BE(val & 0xffff, offset + 1, noAssert);
|
||
|
}
|
||
|
module.exports.writeInt24BE = writeInt24BE;
|
||
|
|
||
|
function readInt40BE(buf, offset, noAssert) {
|
||
|
return (buf.readInt8(offset, noAssert) || 0) * SHIFT_LEFT_32 + buf.readUInt32BE(offset + 1, noAssert);
|
||
|
}
|
||
|
module.exports.readInt40BE = readInt40BE;
|
||
|
|
||
|
function writeInt40BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x8000000000, 0x7fffffffff);
|
||
|
assert.ok(offset + 5 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeInt8(Math.floor(val * SHIFT_RIGHT_32), offset, noAssert);
|
||
|
buf.writeInt32BE(val & -1, offset + 1, noAssert);
|
||
|
}
|
||
|
module.exports.writeInt40BE = writeInt40BE;
|
||
|
|
||
|
function readInt48BE(buf, offset, noAssert) {
|
||
|
return buf.readInt16BE(offset, noAssert) * SHIFT_LEFT_32 + buf.readUInt32BE(offset + 2, noAssert);
|
||
|
}
|
||
|
module.exports.readInt48BE = readInt48BE;
|
||
|
|
||
|
function writeInt48BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x800000000000, 0x7fffffffffff);
|
||
|
assert.ok(offset + 6 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeInt16BE(Math.floor(val * SHIFT_RIGHT_32), offset, noAssert);
|
||
|
buf.writeInt32BE(val & -1, offset + 2, noAssert);
|
||
|
}
|
||
|
module.exports.writeInt48BE = writeInt48BE;
|
||
|
|
||
|
function readInt56BE(buf, offset, noAssert) {
|
||
|
return (((buf.readInt8(offset, noAssert) || 0) << 16) + buf.readUInt16BE(offset + 1, noAssert)) * SHIFT_LEFT_32 + buf.readUInt32BE(offset + 3, noAssert);
|
||
|
}
|
||
|
module.exports.readInt56BE = readInt56BE;
|
||
|
|
||
|
function writeInt56BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x800000000000000, 0x7fffffffffffff);
|
||
|
assert.ok(offset + 7 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
if (val < 0x80000000000000) {
|
||
|
var hi = Math.floor(val * SHIFT_RIGHT_32);
|
||
|
buf.writeInt8(hi >> 16, offset, noAssert);
|
||
|
buf.writeUInt16BE(hi & 0xffff, offset + 1, noAssert);
|
||
|
buf.writeInt32BE(val & -1, offset + 3, noAssert);
|
||
|
} else {
|
||
|
// Special case because 2^55-1 gets rounded up to 2^55
|
||
|
buf[offset] = 0x7f;
|
||
|
buf[offset+1] = 0xff;
|
||
|
buf[offset+2] = 0xff;
|
||
|
buf[offset+3] = 0xff;
|
||
|
buf[offset+4] = 0xff;
|
||
|
buf[offset+5] = 0xff;
|
||
|
buf[offset+6] = 0xff;
|
||
|
}
|
||
|
}
|
||
|
module.exports.writeInt56BE = writeInt56BE;
|
||
|
|
||
|
function readInt64BE(buf, offset, noAssert) {
|
||
|
return buf.readInt32BE(offset, noAssert) * SHIFT_LEFT_32 + buf.readUInt32BE(offset + 4, noAssert);
|
||
|
}
|
||
|
module.exports.readInt64BE = readInt64BE;
|
||
|
|
||
|
function writeInt64BE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x800000000000000000, 0x7fffffffffffffff);
|
||
|
assert.ok(offset + 8 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
if (val < 0x8000000000000000) {
|
||
|
buf.writeInt32BE(Math.floor(val * SHIFT_RIGHT_32), offset, noAssert);
|
||
|
buf.writeInt32BE(val & -1, offset + 4, noAssert);
|
||
|
} else {
|
||
|
// Special case because 2^63-1 gets rounded up to 2^63
|
||
|
buf[offset] = 0x7f;
|
||
|
buf[offset+1] = 0xff;
|
||
|
buf[offset+2] = 0xff;
|
||
|
buf[offset+3] = 0xff;
|
||
|
buf[offset+4] = 0xff;
|
||
|
buf[offset+5] = 0xff;
|
||
|
buf[offset+6] = 0xff;
|
||
|
buf[offset+7] = 0xff;
|
||
|
}
|
||
|
}
|
||
|
module.exports.writeInt64BE = writeInt64BE;
|
||
|
|
||
|
function readInt24LE(buf, offset, noAssert) {
|
||
|
return (buf.readInt8(offset + 2, noAssert) << 16) + buf.readUInt16LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readInt24LE = readInt24LE;
|
||
|
|
||
|
function writeInt24LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x800000, 0x7fffff);
|
||
|
assert.ok(offset + 3 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeUInt16LE(val & 0xffff, offset, noAssert);
|
||
|
buf.writeInt8(val >> 16, offset + 2, noAssert);
|
||
|
}
|
||
|
module.exports.writeInt24LE = writeInt24LE;
|
||
|
|
||
|
function readInt40LE(buf, offset, noAssert) {
|
||
|
return (buf.readInt8(offset + 4, noAssert) || 0) * SHIFT_LEFT_32 + buf.readUInt32LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readInt40LE = readInt40LE;
|
||
|
|
||
|
function writeInt40LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x8000000000, 0x7fffffffff);
|
||
|
assert.ok(offset + 5 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeInt32LE(val & -1, offset, noAssert);
|
||
|
buf.writeInt8(Math.floor(val * SHIFT_RIGHT_32), offset + 4, noAssert);
|
||
|
}
|
||
|
module.exports.writeInt40LE = writeInt40LE;
|
||
|
|
||
|
function readInt48LE(buf, offset, noAssert) {
|
||
|
return buf.readInt16LE(offset + 4, noAssert) * SHIFT_LEFT_32 + buf.readUInt32LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readInt48LE = readInt48LE;
|
||
|
|
||
|
function writeInt48LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x800000000000, 0x7fffffffffff);
|
||
|
assert.ok(offset + 6 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
buf.writeInt32LE(val & -1, offset, noAssert);
|
||
|
buf.writeInt16LE(Math.floor(val * SHIFT_RIGHT_32), offset + 4, noAssert);
|
||
|
}
|
||
|
module.exports.writeInt48LE = writeInt48LE;
|
||
|
|
||
|
function readInt56LE(buf, offset, noAssert) {
|
||
|
return (((buf.readInt8(offset + 6, noAssert) || 0) << 16) + buf.readUInt16LE(offset + 4, noAssert)) * SHIFT_LEFT_32 + buf.readUInt32LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readInt56LE = readInt56LE;
|
||
|
|
||
|
function writeInt56LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x80000000000000, 0x7fffffffffffff);
|
||
|
assert.ok(offset + 7 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
if (val < 0x80000000000000) {
|
||
|
buf.writeInt32LE(val & -1, offset, noAssert);
|
||
|
var hi = Math.floor(val * SHIFT_RIGHT_32);
|
||
|
buf.writeUInt16LE(hi & 0xffff, offset + 4, noAssert);
|
||
|
buf.writeInt8(hi >> 16, offset + 6, noAssert);
|
||
|
} else {
|
||
|
// Special case because 2^55-1 gets rounded up to 2^55
|
||
|
buf[offset] = 0xff;
|
||
|
buf[offset+1] = 0xff;
|
||
|
buf[offset+2] = 0xff;
|
||
|
buf[offset+3] = 0xff;
|
||
|
buf[offset+4] = 0xff;
|
||
|
buf[offset+5] = 0xff;
|
||
|
buf[offset+6] = 0x7f;
|
||
|
}
|
||
|
}
|
||
|
module.exports.writeInt56LE = writeInt56LE;
|
||
|
|
||
|
function readInt64LE(buf, offset, noAssert) {
|
||
|
return buf.readInt32LE(offset + 4, noAssert) * SHIFT_LEFT_32 + buf.readUInt32LE(offset, noAssert);
|
||
|
}
|
||
|
module.exports.readInt64LE = readInt64LE;
|
||
|
|
||
|
function writeInt64LE(buf, val, offset, noAssert) {
|
||
|
if (!noAssert) {
|
||
|
check_int(val, -0x8000000000000000, 0x7fffffffffffffff);
|
||
|
assert.ok(offset + 8 <= buf.length, "attempt to write beyond end of buffer");
|
||
|
}
|
||
|
|
||
|
if (val < 0x8000000000000000) {
|
||
|
buf.writeInt32LE(val & -1, offset, noAssert);
|
||
|
buf.writeInt32LE(Math.floor(val * SHIFT_RIGHT_32), offset + 4, noAssert);
|
||
|
} else {
|
||
|
// Special case because 2^55-1 gets rounded up to 2^55
|
||
|
buf[offset] = 0xff;
|
||
|
buf[offset+1] = 0xff;
|
||
|
buf[offset+2] = 0xff;
|
||
|
buf[offset+3] = 0xff;
|
||
|
buf[offset+4] = 0xff;
|
||
|
buf[offset+5] = 0xff;
|
||
|
buf[offset+6] = 0xff;
|
||
|
buf[offset+7] = 0x7f;
|
||
|
}
|
||
|
}
|
||
|
module.exports.writeInt64LE = writeInt64LE;
|