| // 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. |
| */ |
| |
| |
| export 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. |
| */ |
| |
| export 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). |
| */ |
| |
| export 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. |
| */ |
| |
| export 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. |
| */ |
| |
| export 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. |
| */ |
| |
| export 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. |
| */ |
| |
| export 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); |
| } |