File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.alloc = alloc;
exports.free = free;
exports.resize = resize;
exports.readInt = readInt;
exports.readUInt = readUInt;
exports.writeInt64 = writeInt64;
exports.writeUInt64 = writeUInt64;
// Copyright 2012 The Obvious Corporation.
/*
* bufs: Buffer utilities.
*/
/*
* Module variables
*/
/** Pool of buffers, where `bufPool[x].length === x`. */
var bufPool = [];
/** Maximum length of kept temporary buffers. */
var TEMP_BUF_MAXIMUM_LENGTH = 20;
/** Minimum exactly-representable 64-bit int. */
var MIN_EXACT_INT64 = -0x8000000000000000;
/** Maximum exactly-representable 64-bit int. */
var MAX_EXACT_INT64 = 0x7ffffffffffffc00;
/** Maximum exactly-representable 64-bit uint. */
var MAX_EXACT_UINT64 = 0xfffffffffffff800;
/**
* The int value consisting just of a 1 in bit #32 (that is, one more
* than the maximum 32-bit unsigned value).
*/
var BIT_32 = 0x100000000;
/**
* The int value consisting just of a 1 in bit #64 (that is, one more
* than the maximum 64-bit unsigned value).
*/
var BIT_64 = 0x10000000000000000;
/*
* Helper functions
*/
/**
* Masks off all but the lowest bit set of the given number.
*/
function lowestBit(num) {
return num & -num;
}
/**
* Gets whether trying to add the second number to the first is lossy
* (inexact). The first number is meant to be an accumulated result.
*/
function isLossyToAdd(accum, num) {
if (num === 0) {
return false;
}
var lowBit = lowestBit(num);
var added = accum + lowBit;
if (added === accum) {
return true;
}
if (added - lowBit !== accum) {
return true;
}
return false;
}
/*
* Exported functions
*/
/**
* Allocates a buffer of the given length, which is initialized
* with all zeroes. This returns a buffer from the pool if it is
* available, or a freshly-allocated buffer if not.
*/
function alloc(length) {
var result = bufPool[length];
if (result) {
bufPool[length] = undefined;
} else {
result = new Buffer(length);
}
result.fill(0);
return result;
}
/**
* Releases a buffer back to the pool.
*/
function free(buffer) {
var length = buffer.length;
if (length < TEMP_BUF_MAXIMUM_LENGTH) {
bufPool[length] = buffer;
}
}
/**
* Resizes a buffer, returning a new buffer. Returns the argument if
* the length wouldn't actually change. This function is only safe to
* use if the given buffer was allocated within this module (since
* otherwise the buffer might possibly be shared externally).
*/
function resize(buffer, length) {
if (length === buffer.length) {
return buffer;
}
var newBuf = alloc(length);
buffer.copy(newBuf);
free(buffer);
return newBuf;
}
/**
* Reads an arbitrary signed int from a buffer.
*/
function readInt(buffer) {
var length = buffer.length;
var positive = buffer[length - 1] < 0x80;
var result = positive ? 0 : -1;
var lossy = false; // Note: We can't use bit manipulation here, since that stops
// working if the result won't fit in a 32-bit int.
if (length < 7) {
// Common case which can't possibly be lossy (because the result has
// no more than 48 bits, and loss only happens with 54 or more).
for (var i = length - 1; i >= 0; i--) {
result = result * 0x100 + buffer[i];
}
} else {
for (var _i = length - 1; _i >= 0; _i--) {
var one = buffer[_i];
result *= 0x100;
if (isLossyToAdd(result, one)) {
lossy = true;
}
result += one;
}
}
return {
value: result,
lossy: lossy
};
}
/**
* Reads an arbitrary unsigned int from a buffer.
*/
function readUInt(buffer) {
var length = buffer.length;
var result = 0;
var lossy = false; // Note: See above in re bit manipulation.
if (length < 7) {
// Common case which can't possibly be lossy (see above).
for (var i = length - 1; i >= 0; i--) {
result = result * 0x100 + buffer[i];
}
} else {
for (var _i2 = length - 1; _i2 >= 0; _i2--) {
var one = buffer[_i2];
result *= 0x100;
if (isLossyToAdd(result, one)) {
lossy = true;
}
result += one;
}
}
return {
value: result,
lossy: lossy
};
}
/**
* Writes a little-endian 64-bit signed int into a buffer.
*/
function writeInt64(value, buffer) {
if (value < MIN_EXACT_INT64 || value > MAX_EXACT_INT64) {
throw new Error("Value out of range.");
}
if (value < 0) {
value += BIT_64;
}
writeUInt64(value, buffer);
}
/**
* Writes a little-endian 64-bit unsigned int into a buffer.
*/
function writeUInt64(value, buffer) {
if (value < 0 || value > MAX_EXACT_UINT64) {
throw new Error("Value out of range.");
}
var lowWord = value % BIT_32;
var highWord = Math.floor(value / BIT_32);
buffer.writeUInt32LE(lowWord, 0);
buffer.writeUInt32LE(highWord, 4);
}