Update typed arrays behavior to match ES6 rev 15. Remove TO_POSITIVE_INTEGER and throw on negative …

src/typedarray.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 19 matching lines @@
 // This file relies on the fact that the following declaration has been made
 // in runtime.js:
 // var $Array = global.Array;
 
 
 
 // --------------- Typed Arrays ---------------------
 
 function CreateTypedArrayConstructor(name, elementSize, arrayId, constructor) {
   function ConstructByArrayBuffer(obj, buffer, byteOffset, length) {
-    var offset = IS_UNDEFINED(byteOffset) ? 0 : TO_POSITIVE_INTEGER(byteOffset);
+    var offset = ToPositiveInteger(byteOffset, "invalid_typed_array_length")
 
     if (offset % elementSize !== 0) {
       throw MakeRangeError("invalid_typed_array_alignment",
           "start offset", name, elementSize);
     }
     var bufferByteLength = %ArrayBufferGetByteLength(buffer);
     if (offset > bufferByteLength) {
       throw MakeRangeError("invalid_typed_array_offset");
     }
 
     var newByteLength;
     var newLength;
     if (IS_UNDEFINED(length)) {
       if (bufferByteLength % elementSize !== 0) {
         throw MakeRangeError("invalid_typed_array_alignment",
           "byte length", name, elementSize);
       }
       newByteLength = bufferByteLength - offset;
       newLength = newByteLength / elementSize;
     } else {
-      var newLength = TO_POSITIVE_INTEGER(length);
+      var newLength = ToPositiveInteger(length, "invalid_typed_array_length");
       newByteLength = newLength * elementSize;
     }
     if (offset + newByteLength > bufferByteLength) {
       throw MakeRangeError("invalid_typed_array_length");
     }
     %TypedArrayInitialize(obj, arrayId, buffer, offset, newByteLength);
   }
 
   function ConstructByLength(obj, length) {
-    var l = IS_UNDEFINED(length) ? 0 : TO_POSITIVE_INTEGER(length);
+    var l = ToPositiveInteger(length, "invalid_typed_array_length");
     var byteLength = l * elementSize;
     var buffer = new global.ArrayBuffer(byteLength);
     %TypedArrayInitialize(obj, arrayId, buffer, 0, byteLength);
   }
 
   function ConstructByArrayLike(obj, arrayLike) {
     var length = arrayLike.length;
-    var l =  IS_UNDEFINED(length) ? 0 : TO_POSITIVE_INTEGER(length);
+    var l =  ToPositiveInteger(length, "invalid_typed_array_length");
     var byteLength = l * elementSize;
     var buffer = new $ArrayBuffer(byteLength);
     %TypedArrayInitialize(obj, arrayId, buffer, 0, byteLength);
     for (var i = 0; i < l; i++) {
       obj[i] = arrayLike[i];
     }
   }
 
   return function (arg1, arg2, arg3) {
     if (%_IsConstructCall()) {
@@ skipping 49 matching lines @@
     }
     var newLength = endInt - beginInt;
     var beginByteOffset =
         %TypedArrayGetByteOffset(this) + beginInt * elementSize;
     return new constructor(%TypedArrayGetBuffer(this),
                            beginByteOffset, newLength);
   }
 }
 
 function TypedArraySet(obj, offset) {
-  var intOffset = IS_UNDEFINED(offset) ? 0 : TO_POSITIVE_INTEGER(offset);
+  var intOffset = IS_UNDEFINED(offset) ? 0 : TO_INTEGER(offset);
+  if (intOffset < 0) {
+    throw MakeTypeError("typed_array_set_negative_offset");
+  }
   if (%TypedArraySetFastCases(this, obj, intOffset))
     return;
 
   var l = obj.length;
   if (IS_UNDEFINED(l)) {
     throw MakeTypeError("invalid_argument");
   }
   if (intOffset + l > this.length) {
     throw MakeRangeError("typed_array_set_source_too_large");
   }
@@ skipping 42 matching lines @@
 // --------------------------- DataView -----------------------------
 
 var $DataView = global.DataView;
 
 function DataViewConstructor(buffer, byteOffset, byteLength) { // length = 3
   if (%_IsConstructCall()) {
     if (!IS_ARRAYBUFFER(buffer)) {
       throw MakeTypeError('data_view_not_array_buffer', []);
     }
     var bufferByteLength = %ArrayBufferGetByteLength(buffer);
-    var offset = IS_UNDEFINED(byteOffset) ? 0 : TO_POSITIVE_INTEGER(byteOffset);
+    var offset = ToPositiveInteger(byteOffset, 'invalid_data_view_offset');
     if (offset > bufferByteLength) {
-      throw MakeRangeError('invalid_data_view_offset', []);
+      throw MakeRangeError('invalid_data_view_offset');
     }
     var length = IS_UNDEFINED(byteLength) ?
-      bufferByteLength - offset : TO_POSITIVE_INTEGER(byteLength);
-    if (offset + length > bufferByteLength) {
+      bufferByteLength - offset : TO_INTEGER(byteLength);
+    if (length < 0 || offset + length > bufferByteLength) {
       throw new MakeRangeError('invalid_data_view_length');
     }
     %DataViewInitialize(this, buffer, offset, length);
   } else {
     return new $DataView(buffer, byteOffset, byteLength)
   }
 }
 
 function DataViewGetBuffer() {
   if (!IS_DATAVIEW(this)) {
@@ skipping 12 matching lines @@
 }
 
 function DataViewGetByteLength() {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.byteLength', this]);
   }
   return %DataViewGetByteLength(this);
 }
 
+function ToPositiveDataViewOffset(offset) {
+  return ToPositiveInteger(offset, 'invalid_data_view_accessor_offset');
+}
+
 function DataViewGetInt8(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.getInt8', this]);
   }
-  return %DataViewGetInt8(this, TO_POSITIVE_INTEGER(offset), !!little_endian);
+  return %DataViewGetInt8(this,
+                          ToPositiveDataViewOffset(offset),
+                          !!little_endian);
 }
 
 function DataViewSetInt8(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.setInt8', this]);
   }
   %DataViewSetInt8(this,
-                   TO_POSITIVE_INTEGER(offset),
+                   ToPositiveDataViewOffset(offset),
                    TO_NUMBER_INLINE(value),
                    !!little_endian);
 }
 
 function DataViewGetUint8(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.getUint8', this]);
   }
-  return %DataViewGetUint8(this, TO_POSITIVE_INTEGER(offset), !!little_endian);
+  return %DataViewGetUint8(this,
+                           ToPositiveDataViewOffset(offset),
+                           !!little_endian);
 }
 
 function DataViewSetUint8(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.setUint8', this]);
   }
   %DataViewSetUint8(this,
-                   TO_POSITIVE_INTEGER(offset),
+                   ToPositiveDataViewOffset(offset),
                    TO_NUMBER_INLINE(value),
                    !!little_endian);
 }
 
 function DataViewGetInt16(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.getInt16', this]);
   }
-  return %DataViewGetInt16(this, TO_POSITIVE_INTEGER(offset), !!little_endian);
+  return %DataViewGetInt16(this,
+                           ToPositiveDataViewOffset(offset),
+                           !!little_endian);
 }
 
 function DataViewSetInt16(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.setInt16', this]);
   }
   %DataViewSetInt16(this,
-                    TO_POSITIVE_INTEGER(offset),
+                    ToPositiveDataViewOffset(offset),
                     TO_NUMBER_INLINE(value),
                     !!little_endian);
 }
 
 function DataViewGetUint16(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.getUint16', this]);
   }
-  return %DataViewGetUint16(this, TO_POSITIVE_INTEGER(offset), !!little_endian);
+  return %DataViewGetUint16(this,
+                            ToPositiveDataViewOffset(offset),
+                            !!little_endian);
 }
 
 function DataViewSetUint16(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.setUint16', this]);
   }
   %DataViewSetUint16(this,
-                     TO_POSITIVE_INTEGER(offset),
+                     ToPositiveDataViewOffset(offset),
                      TO_NUMBER_INLINE(value),
                      !!little_endian);
 }
 
 function DataViewGetInt32(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.getInt32', this]);
   }
-  return %DataViewGetInt32(this, TO_POSITIVE_INTEGER(offset), !!little_endian);
+  return %DataViewGetInt32(this,
+                           ToPositiveDataViewOffset(offset),
+                           !!little_endian);
 }
 
 function DataViewSetInt32(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.setInt32', this]);
   }
   %DataViewSetInt32(this,
-                    TO_POSITIVE_INTEGER(offset),
+                    ToPositiveDataViewOffset(offset),
                     TO_NUMBER_INLINE(value),
                     !!little_endian);
 }
 
 function DataViewGetUint32(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.getUint32', this]);
   }
-  return %DataViewGetUint32(this, TO_POSITIVE_INTEGER(offset), !!little_endian);
+  return %DataViewGetUint32(this,
+                            ToPositiveDataViewOffset(offset),
+                            !!little_endian);
 }
 
 function DataViewSetUint32(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.setUint32', this]);
   }
   %DataViewSetUint32(this,
-                     TO_POSITIVE_INTEGER(offset),
+                     ToPositiveDataViewOffset(offset),
                      TO_NUMBER_INLINE(value),
                      !!little_endian);
 }
 
 function DataViewGetFloat32(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.getFloat32', this]);
   }
-  return %DataViewGetFloat32(this, TO_POSITIVE_INTEGER(offset), !!little_endian);
+  return %DataViewGetFloat32(this,
+                             ToPositiveDataViewOffset(offset),
+                             !!little_endian);
 }
 
 function DataViewSetFloat32(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.setFloat32', this]);
   }
   %DataViewSetFloat32(this,
-                      TO_POSITIVE_INTEGER(offset),
+                      ToPositiveDataViewOffset(offset),
                       TO_NUMBER_INLINE(value),
                       !!little_endian);
 }
 
 function DataViewGetFloat64(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.getFloat64', this]);
   }
-  return %DataViewGetFloat64(this, TO_POSITIVE_INTEGER(offset), !!little_endian);
+  offset = TO_INTEGER(offset);
+  if (offset < 0) {
+    throw MakeRangeError("invalid_data_view_accessor_offset");
+  }
+  return %DataViewGetFloat64(this,
+                             ToPositiveDataViewOffset(offset),
+                             !!little_endian);
 }
 
 function DataViewSetFloat64(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
     throw MakeTypeError('incompatible_method_reciever',
                         ['DataView.setFloat64', this]);
   }
+  offset = TO_INTEGER(offset);
+  if (offset < 0) {
+    throw MakeRangeError("invalid_data_view_accessor_offset");
+  }
   %DataViewSetFloat64(this,
-                      TO_POSITIVE_INTEGER(offset),
+                      ToPositiveDataViewOffset(offset),
                       TO_NUMBER_INLINE(value),
                       !!little_endian);
 }
 
 function SetupDataView() {
   %CheckIsBootstrapping();
 
   // Setup the DataView constructor.
   %SetCode($DataView, DataViewConstructor);
   %FunctionSetPrototype($DataView, new $Object);
@@ skipping 26 matching lines @@
 
       "getFloat32", DataViewGetFloat32,
       "setFloat32", DataViewSetFloat32,
 
       "getFloat64", DataViewGetFloat64,
       "setFloat64", DataViewSetFloat64
   ));
 }
 
 SetupDataView();