| Path : /var/www/html/tool-ob/ToolsPortal/node_modules/buffercursor/ |
|
B-Con CMD Config cPanel C-Rdp D-Log Info Jump Mass Ransom Symlink vHost Zone-H |
| Current File : /var/www/html/tool-ob/ToolsPortal/node_modules/buffercursor/buffercursor.js |
// Copyright 2012 Timothy J Fontaine <tjfontaine@gmail.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE
var util = require('util');
var VError = require('verror');
var BufferCursor = module.exports = function(buff, noAssert) {
if (!(this instanceof BufferCursor))
return new BufferCursor(buff, noAssert);
this._pos = 0;
this._noAssert = noAssert;
if (this._noAssert === undefined)
this._noAssert = true;
this.buffer = buff;
this.length = buff.length;
};
var BCO = BufferCursor.BufferCursorOverflow = function(length, pos, size) {
this.kind = 'BufferCursorOverflow';
this.length = length;
this.position = pos;
this.size = size;
VError.call(this,
'BufferCursorOverflow: length %d, position %d, size %d',
length,
pos,
size);
};
util.inherits(BCO, VError);
BufferCursor.prototype._move = function(step) {
this._checkWrite(step);
this._pos += step;
};
BufferCursor.prototype._checkWrite = function(size) {
var shouldThrow = false;
var length = this.length;
var pos = this._pos;
if (size > length)
shouldThrow = true;
if (length - pos < size)
shouldThrow = true;
if (shouldThrow) {
var bco = new BCO(length,
pos,
size);
throw bco;
}
}
BufferCursor.prototype.seek = function(pos) {
if (pos < 0)
throw new VError(new RangeError('Cannot seek before start of buffer'),
'Negative seek values not allowed: %d', pos);
if (pos > this.length)
throw new VError(new RangeError('Trying to seek beyond buffer'),
'Requested %d position is beyond length %d',
pos, this.length);
this._pos = pos;
return this;
};
BufferCursor.prototype.eof = function() {
return this._pos == this.length;
};
BufferCursor.prototype.toByteArray = function(method) {
var arr = [], i, part, count;
if (!method) {
method = 'readUInt8';
part = 1;
}
if (method.indexOf('16') > 0)
part = 2;
else if (method.indexOf('32') > 0)
part = 4;
count = this.length / part;
for (i = 0; i < this.buffer.length; i += part) {
arr.push(this.buffer[method](i));
}
return arr;
};
BufferCursor.prototype.tell = function() {
return this._pos;
};
BufferCursor.prototype.slice = function(length) {
var end, b;
if (length === undefined) {
end = this.length;
} else {
end = this._pos + length;
}
b = new BufferCursor(this.buffer.slice(this._pos, end));
this.seek(end);
return b;
};
BufferCursor.prototype.toString = function(encoding, length) {
var end, ret;
if (length === undefined) {
end = this.length;
} else {
end = this._pos + length;
}
if (!encoding) {
encoding = 'utf8';
}
ret = this.buffer.toString(encoding, this._pos, end);
this.seek(end);
return ret;
};
// This method doesn't need to _checkWrite because Buffer implicitly truncates
// to the length of the buffer, it's the only method in Node core that behaves
// this way by default
BufferCursor.prototype.write = function(value, length, encoding) {
var end, ret;
ret = this.buffer.write(value, this._pos, length, encoding);
this._move(ret);
return this;
};
BufferCursor.prototype.fill = function(value, length) {
var end;
if (length === undefined) {
end = this.length;
} else {
end = this._pos + length;
}
this._checkWrite(end - this._pos);
this.buffer.fill(value, this._pos, end);
this.seek(end);
return this;
};
// This prototype is not entirely like the upstream Buffer.copy, instead it
// is the target buffer, and accepts the source buffer -- since the target
// buffer knows its starting position
BufferCursor.prototype.copy = function copy(source, sourceStart, sourceEnd) {
var sBC = source instanceof BufferCursor;
if (isNaN(sourceEnd))
sourceEnd = source.length;
if (isNaN(sourceStart)) {
if (sBC)
sourceStart = source._pos;
else
sourceStart = 0;
}
var length = sourceEnd - sourceStart;
this._checkWrite(length);
var buf = sBC ? source.buffer : source;
buf.copy(this.buffer, this._pos, sourceStart, sourceEnd);
this._move(length);
return this;
};
BufferCursor.prototype.readUInt8 = function() {
var ret = this.buffer.readUInt8(this._pos, this._noAssert);
this._move(1);
return ret;
};
BufferCursor.prototype.readInt8 = function() {
var ret = this.buffer.readInt8(this._pos, this._noAssert);
this._move(1);
return ret;
};
BufferCursor.prototype.readInt16BE = function() {
var ret = this.buffer.readInt16BE(this._pos, this._noAssert);
this._move(2);
return ret;
};
BufferCursor.prototype.readInt16LE = function() {
var ret = this.buffer.readInt16LE(this._pos, this._noAssert);
this._move(2);
return ret;
};
BufferCursor.prototype.readUInt16BE = function() {
var ret = this.buffer.readUInt16BE(this._pos, this._noAssert);
this._move(2);
return ret;
};
BufferCursor.prototype.readUInt16LE = function() {
var ret = this.buffer.readUInt16LE(this._pos, this._noAssert);
this._move(2);
return ret;
};
BufferCursor.prototype.readUInt32LE = function() {
var ret = this.buffer.readUInt32LE(this._pos, this._noAssert);
this._move(4);
return ret;
};
BufferCursor.prototype.readUInt32BE = function() {
var ret = this.buffer.readUInt32BE(this._pos, this._noAssert);
this._move(4);
return ret;
};
BufferCursor.prototype.readInt32LE = function() {
var ret = this.buffer.readInt32LE(this._pos, this._noAssert);
this._move(4);
return ret;
};
BufferCursor.prototype.readInt32BE = function() {
var ret = this.buffer.readInt32BE(this._pos, this._noAssert);
this._move(4);
return ret;
};
BufferCursor.prototype.readFloatBE = function() {
var ret = this.buffer.readFloatBE(this._pos, this._noAssert);
this._move(4);
return ret;
};
BufferCursor.prototype.readFloatLE = function() {
var ret = this.buffer.readFloatLE(this._pos, this._noAssert);
this._move(4);
return ret;
};
BufferCursor.prototype.readDoubleBE = function() {
var ret = this.buffer.readDoubleBE(this._pos, this._noAssert);
this._move(8);
return ret;
};
BufferCursor.prototype.readDoubleLE = function() {
var ret = this.buffer.readDoubleLE(this._pos, this._noAssert);
this._move(8);
return ret;
};
BufferCursor.prototype.writeUInt8 = function(value) {
this._checkWrite(1);
this.buffer.writeUInt8(value, this._pos, this._noAssert);
this._move(1);
return this;
};
BufferCursor.prototype.writeInt8 = function(value) {
this._checkWrite(1);
this.buffer.writeInt8(value, this._pos, this._noAssert);
this._move(1);
return this;
};
BufferCursor.prototype.writeUInt16BE = function(value) {
this._checkWrite(2);
this.buffer.writeUInt16BE(value, this._pos, this._noAssert);
this._move(2);
return this;
};
BufferCursor.prototype.writeUInt16LE = function(value) {
this._checkWrite(2);
this.buffer.writeUInt16LE(value, this._pos, this._noAssert);
this._move(2);
return this;
};
BufferCursor.prototype.writeInt16BE = function(value) {
this._checkWrite(2);
this.buffer.writeInt16BE(value, this._pos, this._noAssert);
this._move(2);
return this;
};
BufferCursor.prototype.writeInt16LE = function(value) {
this._checkWrite(2);
this.buffer.writeInt16LE(value, this._pos, this._noAssert);
this._move(2);
return this;
};
BufferCursor.prototype.writeUInt32BE = function(value) {
this._checkWrite(4);
this.buffer.writeUInt32BE(value, this._pos, this._noAssert);
this._move(4);
return this;
};
BufferCursor.prototype.writeUInt32LE = function(value) {
this._checkWrite(4);
this.buffer.writeUInt32LE(value, this._pos, this._noAssert);
this._move(4);
return this;
};
BufferCursor.prototype.writeInt32BE = function(value) {
this._checkWrite(4);
this.buffer.writeInt32BE(value, this._pos, this._noAssert);
this._move(4);
return this;
};
BufferCursor.prototype.writeInt32LE = function(value) {
this._checkWrite(4);
this.buffer.writeInt32LE(value, this._pos, this._noAssert);
this._move(4);
return this;
};
BufferCursor.prototype.writeFloatBE = function(value) {
this._checkWrite(4);
this.buffer.writeFloatBE(value, this._pos, this._noAssert);
this._move(4);
return this;
};
BufferCursor.prototype.writeFloatLE = function(value) {
this._checkWrite(4);
this.buffer.writeFloatLE(value, this._pos, this._noAssert);
this._move(4);
return this;
};
BufferCursor.prototype.writeDoubleBE = function(value) {
this._checkWrite(8);
this.buffer.writeDoubleBE(value, this._pos, this._noAssert);
this._move(8);
return this;
};
BufferCursor.prototype.writeDoubleLE = function(value) {
this._checkWrite(8);
this.buffer.writeDoubleLE(value, this._pos, this._noAssert);
this._move(8);
return this;
};