lib/buffer.js

   1 'use strict';
   2
   3 var buffer = process.binding('buffer');
   4 var smalloc = process.binding('smalloc');
   5 var util = require('util');
   6 var alloc = smalloc.alloc;
   7 var truncate = smalloc.truncate;
   8 var sliceOnto = smalloc.sliceOnto;
   9 var kMaxLength = smalloc.kMaxLength;
  10 var internal = {};
  11
  12 exports.Buffer = Buffer;
  13 exports.SlowBuffer = SlowBuffer;
  14 exports.INSPECT_MAX_BYTES = 50;
  15
  16
  17 Buffer.poolSize = 8 * 1024;
  18 var poolSize, poolOffset, allocPool;
  19
  20
  21 function createPool() {
  22   poolSize = Buffer.poolSize;
  23   allocPool = alloc({}, poolSize);
  24   poolOffset = 0;
  25 }
  26 createPool();
  27
  28
  29 function Buffer(subject, encoding) {
  30   if (!util.isBuffer(this))
  31     return new Buffer(subject, encoding);
  32
  33   if (util.isNumber(subject)) {
  34     this.length = subject > 0 ? subject >>> 0 : 0;
  35
  36   } else if (util.isString(subject)) {
  37     if (!util.isString(encoding) || encoding.length === 0)
  38       encoding = 'utf8';
  39     this.length = Buffer.byteLength(subject, encoding);
  40
  41   // Handle Arrays, Buffers, Uint8Arrays or JSON.
  42   } else if (util.isObject(subject)) {
  43     if (subject.type === 'Buffer' && util.isArray(subject.data))
  44       subject = subject.data;
  45     // Must use floor() because array length may be > kMaxLength.
  46     this.length = +subject.length > 0 ? Math.floor(+subject.length) : 0;
  47
  48   } else {
  49     throw new TypeError('must start with number, buffer, array or string');
  50   }
  51
  52   if (this.length > kMaxLength) {
  53     throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
  54                          'size: 0x' + kMaxLength.toString(16) + ' bytes');
  55   }
  56
  57   this.parent = undefined;
  58   if (this.length <= (Buffer.poolSize >>> 1) && this.length > 0) {
  59     if (this.length > poolSize - poolOffset)
  60       createPool();
  61     this.parent = sliceOnto(allocPool,
  62                             this,
  63                             poolOffset,
  64                             poolOffset + this.length);
  65     poolOffset += this.length;
  66   } else {
  67     alloc(this, this.length);
  68   }
  69
  70   if (util.isNumber(subject)) {
  71     return;
  72   }
  73
  74   if (util.isString(subject)) {
  75     // In the case of base64 it's possible that the size of the buffer
  76     // allocated was slightly too large. In this case we need to rewrite
  77     // the length to the actual length written.
  78     var len = this.write(subject, encoding);
  79     // Buffer was truncated after decode, realloc internal ExternalArray
  80     if (len !== this.length) {
  81       var prevLen = this.length;
  82       this.length = len;
  83       truncate(this, this.length);
  84       poolOffset -= (prevLen - len);
  85     }
  86
  87   } else if (util.isBuffer(subject)) {
  88     subject.copy(this, 0, 0, this.length);
  89
  90   } else if (util.isNumber(subject.length) || util.isArray(subject)) {
  91     // Really crappy way to handle Uint8Arrays, but V8 doesn't give a simple
  92     // way to access the data from the C++ API.
  93     for (var i = 0; i < this.length; i++)
  94       this[i] = subject[i];
  95   }
  96 }
  97
  98
  99 function SlowBuffer(length) {
 100   length = length >>> 0;
 101   if (length > kMaxLength) {
 102     throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
 103                          'size: 0x' + kMaxLength.toString(16) + ' bytes');
 104   }
 105   var b = new NativeBuffer(length);
 106   alloc(b, length);
 107   return b;
 108 }
 109
 110
 111 // Bypass all checks for instantiating unallocated Buffer required for
 112 // Objects created in C++. Significantly faster than calling the Buffer
 113 // function.
 114 function NativeBuffer(length) {
 115   this.length = length >>> 0;
 116   // Set this to keep the object map the same.
 117   this.parent = undefined;
 118 }
 119 NativeBuffer.prototype = Buffer.prototype;
 120
 121
 122 // add methods to Buffer prototype
 123 buffer.setupBufferJS(NativeBuffer, internal);
 124
 125
 126 // Static methods
 127
 128 Buffer.isBuffer = function isBuffer(b) {
 129   return util.isBuffer(b);
 130 };
 131
 132
 133 Buffer.compare = function compare(a, b) {
 134   if (!(a instanceof Buffer) ||
 135       !(b instanceof Buffer))
 136     throw new TypeError('Arguments must be Buffers');
 137
 138   return internal.compare(a, b);
 139 };
 140
 141
 142 Buffer.isEncoding = function(encoding) {
 143   switch ((encoding + '').toLowerCase()) {
 144     case 'hex':
 145     case 'utf8':
 146     case 'utf-8':
 147     case 'ascii':
 148     case 'binary':
 149     case 'base64':
 150     case 'ucs2':
 151     case 'ucs-2':
 152     case 'utf16le':
 153     case 'utf-16le':
 154     case 'raw':
 155       return true;
 156
 157     default:
 158       return false;
 159   }
 160 };
 161
 162
 163 Buffer.concat = function(list, length) {
 164   if (!util.isArray(list))
 165     throw new TypeError('Usage: Buffer.concat(list[, length])');
 166
 167   if (util.isUndefined(length)) {
 168     length = 0;
 169     for (var i = 0; i < list.length; i++)
 170       length += list[i].length;
 171   } else {
 172     length = length >>> 0;
 173   }
 174
 175   if (list.length === 0)
 176     return new Buffer(0);
 177   else if (list.length === 1)
 178     return list[0];
 179
 180   var buffer = new Buffer(length);
 181   var pos = 0;
 182   for (var i = 0; i < list.length; i++) {
 183     var buf = list[i];
 184     buf.copy(buffer, pos);
 185     pos += buf.length;
 186   }
 187
 188   return buffer;
 189 };
 190
 191
 192 Buffer.byteLength = function(str, enc) {
 193   var ret;
 194   str = str + '';
 195   switch (enc) {
 196     case 'ascii':
 197     case 'binary':
 198     case 'raw':
 199       ret = str.length;
 200       break;
 201     case 'ucs2':
 202     case 'ucs-2':
 203     case 'utf16le':
 204     case 'utf-16le':
 205       ret = str.length * 2;
 206       break;
 207     case 'hex':
 208       ret = str.length >>> 1;
 209       break;
 210     default:
 211       ret = internal.byteLength(str, enc);
 212   }
 213   return ret;
 214 };
 215
 216
 217 // toString(encoding, start=0, end=buffer.length)
 218 Buffer.prototype.toString = function(encoding, start, end) {
 219   var loweredCase = false;
 220
 221   start = start >>> 0;
 222   end = util.isUndefined(end) || end === Infinity ? this.length : end >>> 0;
 223
 224   if (!encoding) encoding = 'utf8';
 225   if (start < 0) start = 0;
 226   if (end > this.length) end = this.length;
 227   if (end <= start) return '';
 228
 229   while (true) {
 230     switch (encoding) {
 231       case 'hex':
 232         return this.hexSlice(start, end);
 233
 234       case 'utf8':
 235       case 'utf-8':
 236         return this.utf8Slice(start, end);
 237
 238       case 'ascii':
 239         return this.asciiSlice(start, end);
 240
 241       case 'binary':
 242         return this.binarySlice(start, end);
 243
 244       case 'base64':
 245         return this.base64Slice(start, end);
 246
 247       case 'ucs2':
 248       case 'ucs-2':
 249       case 'utf16le':
 250       case 'utf-16le':
 251         return this.ucs2Slice(start, end);
 252
 253       default:
 254         if (loweredCase)
 255           throw new TypeError('Unknown encoding: ' + encoding);
 256         encoding = (encoding + '').toLowerCase();
 257         loweredCase = true;
 258     }
 259   }
 260 };
 261
 262
 263 Buffer.prototype.equals = function equals(b) {
 264   if (!(b instanceof Buffer))
 265     throw new TypeError('Argument must be a Buffer');
 266
 267   return internal.compare(this, b) === 0;
 268 };
 269
 270
 271 // Inspect
 272 Buffer.prototype.inspect = function inspect() {
 273   var str = '';
 274   var max = exports.INSPECT_MAX_BYTES;
 275   if (this.length > 0) {
 276     str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
 277     if (this.length > max)
 278       str += ' ... ';
 279   }
 280   return '<' + this.constructor.name + ' ' + str + '>';
 281 };
 282
 283
 284 Buffer.prototype.compare = function compare(b) {
 285   if (!(b instanceof Buffer))
 286     throw new TypeError('Argument must be a Buffer');
 287
 288   return internal.compare(this, b);
 289 };
 290
 291
 292 Buffer.prototype.fill = function fill(val, start, end) {
 293   start = start >> 0;
 294   end = (end === undefined) ? this.length : end >> 0;
 295
 296   if (start < 0 || end > this.length)
 297     throw new RangeError('out of range index');
 298   if (end <= start)
 299     return this;
 300
 301   if (typeof val !== 'string') {
 302     val = val >>> 0;
 303   } else if (val.length === 1) {
 304     var code = val.charCodeAt(0);
 305     if (code < 256)
 306       val = code;
 307   }
 308
 309   internal.fill(this, val, start, end);
 310
 311   return this;
 312 };
 313
 314
 315 // XXX remove in v0.13
 316 Buffer.prototype.get = util.deprecate(function get(offset) {
 317   offset = ~~offset;
 318   if (offset < 0 || offset >= this.length)
 319     throw new RangeError('index out of range');
 320   return this[offset];
 321 }, '.get() is deprecated. Access using array indexes instead.');
 322
 323
 324 // XXX remove in v0.13
 325 Buffer.prototype.set = util.deprecate(function set(offset, v) {
 326   offset = ~~offset;
 327   if (offset < 0 || offset >= this.length)
 328     throw new RangeError('index out of range');
 329   return this[offset] = v;
 330 }, '.set() is deprecated. Set using array indexes instead.');
 331
 332
 333 // TODO(trevnorris): fix these checks to follow new standard
 334 // write(string, offset = 0, length = buffer.length, encoding = 'utf8')
 335 var writeWarned = false;
 336 var writeMsg = '.write(string, encoding, offset, length) is deprecated.' +
 337                ' Use write(string[, offset[, length]][, encoding]) instead.';
 338 Buffer.prototype.write = function(string, offset, length, encoding) {
 339   // Buffer#write(string);
 340   if (util.isUndefined(offset)) {
 341     encoding = 'utf8';
 342     length = this.length;
 343     offset = 0;
 344
 345   // Buffer#write(string, encoding)
 346   } else if (util.isUndefined(length) && util.isString(offset)) {
 347     encoding = offset;
 348     length = this.length;
 349     offset = 0;
 350
 351   // Buffer#write(string, offset[, length][, encoding])
 352   } else if (isFinite(offset)) {
 353     offset = offset >>> 0;
 354     if (isFinite(length)) {
 355       length = length >>> 0;
 356       if (util.isUndefined(encoding))
 357         encoding = 'utf8';
 358     } else {
 359       encoding = length;
 360       length = undefined;
 361     }
 362
 363   // XXX legacy write(string, encoding, offset, length) - remove in v0.13
 364   } else {
 365     if (!writeWarned) {
 366       if (process.throwDeprecation)
 367         throw new Error(writeMsg);
 368       else if (process.traceDeprecation)
 369         console.trace(writeMsg);
 370       else
 371         console.error(writeMsg);
 372       writeWarned = true;
 373     }
 374
 375     var swap = encoding;
 376     encoding = offset;
 377     offset = length >>> 0;
 378     length = swap;
 379   }
 380
 381   var remaining = this.length - offset;
 382   if (util.isUndefined(length) || length > remaining)
 383     length = remaining;
 384
 385   encoding = !!encoding ? (encoding + '').toLowerCase() : 'utf8';
 386
 387   if (string.length > 0 && (length < 0 || offset < 0))
 388     throw new RangeError('attempt to write outside buffer bounds');
 389
 390   var ret;
 391   switch (encoding) {
 392     case 'hex':
 393       ret = this.hexWrite(string, offset, length);
 394       break;
 395
 396     case 'utf8':
 397     case 'utf-8':
 398       ret = this.utf8Write(string, offset, length);
 399       break;
 400
 401     case 'ascii':
 402       ret = this.asciiWrite(string, offset, length);
 403       break;
 404
 405     case 'binary':
 406       ret = this.binaryWrite(string, offset, length);
 407       break;
 408
 409     case 'base64':
 410       // Warning: maxLength not taken into account in base64Write
 411       ret = this.base64Write(string, offset, length);
 412       break;
 413
 414     case 'ucs2':
 415     case 'ucs-2':
 416     case 'utf16le':
 417     case 'utf-16le':
 418       ret = this.ucs2Write(string, offset, length);
 419       break;
 420
 421     default:
 422       throw new TypeError('Unknown encoding: ' + encoding);
 423   }
 424
 425   return ret;
 426 };
 427
 428
 429 Buffer.prototype.toJSON = function() {
 430   return {
 431     type: 'Buffer',
 432     data: Array.prototype.slice.call(this, 0)
 433   };
 434 };
 435
 436
 437 // TODO(trevnorris): currently works like Array.prototype.slice(), which
 438 // doesn't follow the new standard for throwing on out of range indexes.
 439 Buffer.prototype.slice = function(start, end) {
 440   var len = this.length;
 441   start = ~~start;
 442   end = util.isUndefined(end) ? len : ~~end;
 443
 444   if (start < 0) {
 445     start += len;
 446     if (start < 0)
 447       start = 0;
 448   } else if (start > len) {
 449     start = len;
 450   }
 451
 452   if (end < 0) {
 453     end += len;
 454     if (end < 0)
 455       end = 0;
 456   } else if (end > len) {
 457     end = len;
 458   }
 459
 460   if (end < start)
 461     end = start;
 462
 463   var buf = new NativeBuffer();
 464   sliceOnto(this, buf, start, end);
 465   buf.length = end - start;
 466   if (buf.length > 0)
 467     buf.parent = util.isUndefined(this.parent) ? this : this.parent;
 468
 469   return buf;
 470 };
 471
 472
 473 function checkOffset(offset, ext, length) {
 474   if (offset + ext > length)
 475     throw new RangeError('index out of range');
 476 }
 477
 478
 479 Buffer.prototype.readUIntLE = function(offset, byteLength, noAssert) {
 480   offset = offset >>> 0;
 481   byteLength = byteLength >>> 0;
 482   if (!noAssert)
 483     checkOffset(offset, byteLength, this.length);
 484
 485   var val = this[offset];
 486   var mul = 1;
 487   var i = 0;
 488   while (++i < byteLength && (mul *= 0x100))
 489     val += this[offset + i] * mul;
 490
 491   return val;
 492 };
 493
 494
 495 Buffer.prototype.readUIntBE = function(offset, byteLength, noAssert) {
 496   offset = offset >>> 0;
 497   byteLength = byteLength >>> 0;
 498   if (!noAssert)
 499     checkOffset(offset, byteLength, this.length);
 500
 501   var val = this[offset + --byteLength];
 502   var mul = 1;
 503   while (byteLength > 0 && (mul *= 0x100))
 504     val += this[offset + --byteLength] * mul;
 505
 506   return val;
 507 };
 508
 509
 510 Buffer.prototype.readUInt8 = function(offset, noAssert) {
 511   offset = offset >>> 0;
 512   if (!noAssert)
 513     checkOffset(offset, 1, this.length);
 514   return this[offset];
 515 };
 516
 517
 518 Buffer.prototype.readUInt16LE = function(offset, noAssert) {
 519   offset = offset >>> 0;
 520   if (!noAssert)
 521     checkOffset(offset, 2, this.length);
 522   return this[offset] | (this[offset + 1] << 8);
 523 };
 524
 525
 526 Buffer.prototype.readUInt16BE = function(offset, noAssert) {
 527   offset = offset >>> 0;
 528   if (!noAssert)
 529     checkOffset(offset, 2, this.length);
 530   return (this[offset] << 8) | this[offset + 1];
 531 };
 532
 533
 534 Buffer.prototype.readUInt32LE = function(offset, noAssert) {
 535   offset = offset >>> 0;
 536   if (!noAssert)
 537     checkOffset(offset, 4, this.length);
 538
 539   return ((this[offset]) |
 540       (this[offset + 1] << 8) |
 541       (this[offset + 2] << 16)) +
 542       (this[offset + 3] * 0x1000000);
 543 };
 544
 545
 546 Buffer.prototype.readUInt32BE = function(offset, noAssert) {
 547   offset = offset >>> 0;
 548   if (!noAssert)
 549     checkOffset(offset, 4, this.length);
 550
 551   return (this[offset] * 0x1000000) +
 552       ((this[offset + 1] << 16) |
 553       (this[offset + 2] << 8) |
 554       this[offset + 3]);
 555 };
 556
 557
 558 Buffer.prototype.readIntLE = function(offset, byteLength, noAssert) {
 559   offset = offset >>> 0;
 560   byteLength = byteLength >>> 0;
 561   if (!noAssert)
 562     checkOffset(offset, byteLength, this.length);
 563
 564   var val = this[offset];
 565   var mul = 1;
 566   var i = 0;
 567   while (++i < byteLength && (mul *= 0x100))
 568     val += this[offset + i] * mul;
 569   mul *= 0x80;
 570
 571   if (val >= mul)
 572     val -= Math.pow(2, 8 * byteLength);
 573
 574   return val;
 575 };
 576
 577
 578 Buffer.prototype.readIntBE = function(offset, byteLength, noAssert) {
 579   offset = offset >>> 0;
 580   byteLength = byteLength >>> 0;
 581   if (!noAssert)
 582     checkOffset(offset, byteLength, this.length);
 583
 584   var i = byteLength;
 585   var mul = 1;
 586   var val = this[offset + --i];
 587   while (i > 0 && (mul *= 0x100))
 588     val += this[offset + --i] * mul;
 589   mul *= 0x80;
 590
 591   if (val >= mul)
 592     val -= Math.pow(2, 8 * byteLength);
 593
 594   return val;
 595 };
 596
 597
 598 Buffer.prototype.readInt8 = function(offset, noAssert) {
 599   offset = offset >>> 0;
 600   if (!noAssert)
 601     checkOffset(offset, 1, this.length);
 602   var val = this[offset];
 603   return !(val & 0x80) ? val : (0xff - val + 1) * -1;
 604 };
 605
 606
 607 Buffer.prototype.readInt16LE = function(offset, noAssert) {
 608   offset = offset >>> 0;
 609   if (!noAssert)
 610     checkOffset(offset, 2, this.length);
 611   var val = this[offset] | (this[offset + 1] << 8);
 612   return (val & 0x8000) ? val | 0xFFFF0000 : val;
 613 };
 614
 615
 616 Buffer.prototype.readInt16BE = function(offset, noAssert) {
 617   offset = offset >>> 0;
 618   if (!noAssert)
 619     checkOffset(offset, 2, this.length);
 620   var val = this[offset + 1] | (this[offset] << 8);
 621   return (val & 0x8000) ? val | 0xFFFF0000 : val;
 622 };
 623
 624
 625 Buffer.prototype.readInt32LE = function(offset, noAssert) {
 626   offset = offset >>> 0;
 627   if (!noAssert)
 628     checkOffset(offset, 4, this.length);
 629
 630   return (this[offset]) |
 631       (this[offset + 1] << 8) |
 632       (this[offset + 2] << 16) |
 633       (this[offset + 3] << 24);
 634 };
 635
 636
 637 Buffer.prototype.readInt32BE = function(offset, noAssert) {
 638   offset = offset >>> 0;
 639   if (!noAssert)
 640     checkOffset(offset, 4, this.length);
 641
 642   return (this[offset] << 24) |
 643       (this[offset + 1] << 16) |
 644       (this[offset + 2] << 8) |
 645       (this[offset + 3]);
 646 };
 647
 648
 649 Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
 650   offset = offset >>> 0;
 651   if (!noAssert)
 652     checkOffset(offset, 4, this.length);
 653   return internal.readFloatLE(this, offset);
 654 };
 655
 656
 657 Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
 658   offset = offset >>> 0;
 659   if (!noAssert)
 660     checkOffset(offset, 4, this.length);
 661   return internal.readFloatBE(this, offset);
 662 };
 663
 664
 665 Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
 666   offset = offset >>> 0;
 667   if (!noAssert)
 668     checkOffset(offset, 8, this.length);
 669   return internal.readDoubleLE(this, offset);
 670 };
 671
 672
 673 Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
 674   offset = offset >>> 0;
 675   if (!noAssert)
 676     checkOffset(offset, 8, this.length);
 677   return internal.readDoubleBE(this, offset);
 678 };
 679
 680
 681 function checkInt(buffer, value, offset, ext, max, min) {
 682   if (!(buffer instanceof Buffer))
 683     throw new TypeError('buffer must be a Buffer instance');
 684   if (value > max || value < min)
 685     throw new TypeError('value is out of bounds');
 686   if (offset + ext > buffer.length)
 687     throw new RangeError('index out of range');
 688 }
 689
 690
 691 Buffer.prototype.writeUIntLE = function(value, offset, byteLength, noAssert) {
 692   value = +value;
 693   offset = offset >>> 0;
 694   byteLength = byteLength >>> 0;
 695   if (!noAssert)
 696     checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0);
 697
 698   var mul = 1;
 699   var i = 0;
 700   this[offset] = value;
 701   while (++i < byteLength && (mul *= 0x100))
 702     this[offset + i] = (value / mul) >>> 0;
 703
 704   return offset + byteLength;
 705 };
 706
 707
 708 Buffer.prototype.writeUIntBE = function(value, offset, byteLength, noAssert) {
 709   value = +value;
 710   offset = offset >>> 0;
 711   byteLength = byteLength >>> 0;
 712   if (!noAssert)
 713     checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0);
 714
 715   var i = byteLength - 1;
 716   var mul = 1;
 717   this[offset + i] = value;
 718   while (--i >= 0 && (mul *= 0x100))
 719     this[offset + i] = (value / mul) >>> 0;
 720
 721   return offset + byteLength;
 722 };
 723
 724
 725 Buffer.prototype.writeUInt8 = function(value, offset, noAssert) {
 726   value = +value;
 727   offset = offset >>> 0;
 728   if (!noAssert)
 729     checkInt(this, value, offset, 1, 0xff, 0);
 730   this[offset] = value;
 731   return offset + 1;
 732 };
 733
 734
 735 Buffer.prototype.writeUInt16LE = function(value, offset, noAssert) {
 736   value = +value;
 737   offset = offset >>> 0;
 738   if (!noAssert)
 739     checkInt(this, value, offset, 2, 0xffff, 0);
 740   this[offset] = value;
 741   this[offset + 1] = (value >>> 8);
 742   return offset + 2;
 743 };
 744
 745
 746 Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
 747   value = +value;
 748   offset = offset >>> 0;
 749   if (!noAssert)
 750     checkInt(this, value, offset, 2, 0xffff, 0);
 751   this[offset] = (value >>> 8);
 752   this[offset + 1] = value;
 753   return offset + 2;
 754 };
 755
 756
 757 Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
 758   value = +value;
 759   offset = offset >>> 0;
 760   if (!noAssert)
 761     checkInt(this, value, offset, 4, 0xffffffff, 0);
 762   this[offset + 3] = (value >>> 24);
 763   this[offset + 2] = (value >>> 16);
 764   this[offset + 1] = (value >>> 8);
 765   this[offset] = value;
 766   return offset + 4;
 767 };
 768
 769
 770 Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
 771   value = +value;
 772   offset = offset >>> 0;
 773   if (!noAssert)
 774     checkInt(this, value, offset, 4, 0xffffffff, 0);
 775   this[offset] = (value >>> 24);
 776   this[offset + 1] = (value >>> 16);
 777   this[offset + 2] = (value >>> 8);
 778   this[offset + 3] = value;
 779   return offset + 4;
 780 };
 781
 782
 783 Buffer.prototype.writeIntLE = function(value, offset, byteLength, noAssert) {
 784   value = +value;
 785   offset = offset >>> 0;
 786   if (!noAssert) {
 787     checkInt(this,
 788              value,
 789              offset,
 790              byteLength,
 791              Math.pow(2, 8 * byteLength - 1) - 1,
 792              -Math.pow(2, 8 * byteLength - 1));
 793   }
 794
 795   var i = 0;
 796   var mul = 1;
 797   var sub = value < 0 ? 1 : 0;
 798   this[offset] = value;
 799   while (++i < byteLength && (mul *= 0x100))
 800     this[offset + i] = ((value / mul) >> 0) - sub;
 801
 802   return offset + byteLength;
 803 };
 804
 805
 806 Buffer.prototype.writeIntBE = function(value, offset, byteLength, noAssert) {
 807   value = +value;
 808   offset = offset >>> 0;
 809   if (!noAssert) {
 810     checkInt(this,
 811              value,
 812              offset,
 813              byteLength,
 814              Math.pow(2, 8 * byteLength - 1) - 1,
 815              -Math.pow(2, 8 * byteLength - 1));
 816   }
 817
 818   var i = byteLength - 1;
 819   var mul = 1;
 820   var sub = value < 0 ? 1 : 0;
 821   this[offset + i] = value;
 822   while (--i >= 0 && (mul *= 0x100))
 823     this[offset + i] = ((value / mul) >> 0) - sub;
 824
 825   return offset + byteLength;
 826 };
 827
 828
 829 Buffer.prototype.writeInt8 = function(value, offset, noAssert) {
 830   value = +value;
 831   offset = offset >>> 0;
 832   if (!noAssert)
 833     checkInt(this, value, offset, 1, 0x7f, -0x80);
 834   this[offset] = value;
 835   return offset + 1;
 836 };
 837
 838
 839 Buffer.prototype.writeInt16LE = function(value, offset, noAssert) {
 840   value = +value;
 841   offset = offset >>> 0;
 842   if (!noAssert)
 843     checkInt(this, value, offset, 2, 0x7fff, -0x8000);
 844   this[offset] = value;
 845   this[offset + 1] = (value >>> 8);
 846   return offset + 2;
 847 };
 848
 849
 850 Buffer.prototype.writeInt16BE = function(value, offset, noAssert) {
 851   value = +value;
 852   offset = offset >>> 0;
 853   if (!noAssert)
 854     checkInt(this, value, offset, 2, 0x7fff, -0x8000);
 855   this[offset] = (value >>> 8);
 856   this[offset + 1] = value;
 857   return offset + 2;
 858 };
 859
 860
 861 Buffer.prototype.writeInt32LE = function(value, offset, noAssert) {
 862   value = +value;
 863   offset = offset >>> 0;
 864   if (!noAssert)
 865     checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
 866   this[offset] = value;
 867   this[offset + 1] = (value >>> 8);
 868   this[offset + 2] = (value >>> 16);
 869   this[offset + 3] = (value >>> 24);
 870   return offset + 4;
 871 };
 872
 873
 874 Buffer.prototype.writeInt32BE = function(value, offset, noAssert) {
 875   value = +value;
 876   offset = offset >>> 0;
 877   if (!noAssert)
 878     checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
 879   this[offset] = (value >>> 24);
 880   this[offset + 1] = (value >>> 16);
 881   this[offset + 2] = (value >>> 8);
 882   this[offset + 3] = value;
 883   return offset + 4;
 884 };
 885
 886
 887 function checkFloat(buffer, value, offset, ext) {
 888   if (!(buffer instanceof Buffer))
 889     throw new TypeError('buffer must be a Buffer instance');
 890   if (offset + ext > buffer.length)
 891     throw new RangeError('index out of range');
 892 }
 893
 894
 895 Buffer.prototype.writeFloatLE = function writeFloatLE(val, offset, noAssert) {
 896   val = +val;
 897   offset = offset >>> 0;
 898   if (!noAssert)
 899     checkFloat(this, val, offset, 4);
 900   internal.writeFloatLE(this, val, offset);
 901   return offset + 4;
 902 };
 903
 904
 905 Buffer.prototype.writeFloatBE = function writeFloatBE(val, offset, noAssert) {
 906   val = +val;
 907   offset = offset >>> 0;
 908   if (!noAssert)
 909     checkFloat(this, val, offset, 4);
 910   internal.writeFloatBE(this, val, offset);
 911   return offset + 4;
 912 };
 913
 914
 915 Buffer.prototype.writeDoubleLE = function writeDoubleLE(val, offset, noAssert) {
 916   val = +val;
 917   offset = offset >>> 0;
 918   if (!noAssert)
 919     checkFloat(this, val, offset, 8);
 920   internal.writeDoubleLE(this, val, offset);
 921   return offset + 8;
 922 };
 923
 924
 925 Buffer.prototype.writeDoubleBE = function writeDoubleBE(val, offset, noAssert) {
 926   val = +val;
 927   offset = offset >>> 0;
 928   if (!noAssert)
 929     checkFloat(this, val, offset, 8);
 930   internal.writeDoubleBE(this, val, offset);
 931   return offset + 8;
 932 };