Fix range check bug for ByteData getters and setters.

runtime/lib/typed_data.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // patch classes for Int8List ..... Float64List and ByteData implementations.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
@@ skipping 2808 matching lines @@
     return _typedData._getUint8(_offset + byteOffset);
   }
   void setUint8(int byteOffset, int value) {
     if (byteOffset < 0 || byteOffset >= length) {
       _throwRangeError(byteOffset, length);
     }
     _typedData._setUint8(_offset + byteOffset, _toUint8(value));
   }
 
   int getInt16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 1 >= length) {
+      _throwRangeError(byteOffset + 1, length);
     }
     var result = _typedData._getInt16(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianInt16(result, endian._littleEndian);
   }
   void setInt16(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 1 >= length) {
+      _throwRangeError(byteOffset + 1, length);
     }
     var set_value = _toInt16(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianInt16(set_value, endian._littleEndian);
     }
     _typedData._setInt16(_offset + byteOffset, set_value);
   }
 
   int getUint16(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 1 >= length) {
+      _throwRangeError(byteOffset + 1, length);
     }
     var result = _typedData._getUint16(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianUint16(result, endian._littleEndian);
   }
   void setUint16(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 1 >= length) {
+      _throwRangeError(byteOffset + 1, length);
     }
     var set_value = _toUint16(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianUint16(set_value, endian._littleEndian);
     }
     _typedData._setUint16(_offset + byteOffset, set_value);
   }
 
   int getInt32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 3 >= length) {
+      _throwRangeError(byteOffset + 3, length);
     }
     var result = _typedData._getInt32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianInt32(result, endian._littleEndian);
   }
   void setInt32(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 3 >= length) {
+      _throwRangeError(byteOffset + 3, length);
     }
     var set_value = _toInt32(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianInt32(set_value, endian._littleEndian);
     }
     _typedData._setInt32(_offset + byteOffset, set_value);
   }
 
   int getUint32(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 3 >= length) {
+      _throwRangeError(byteOffset + 3, length);
     }
     var result = _typedData._getUint32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianUint32(result, endian._littleEndian);
   }
   void setUint32(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 3 >= length) {
+      _throwRangeError(byteOffset + 3, length);
     }
     var set_value = _toUint32(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianUint32(set_value, endian._littleEndian);
     }
     _typedData._setUint32(_offset + byteOffset, set_value);
   }
 
   int getInt64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 7 >= length) {
+      _throwRangeError(byteOffset + 7, length);
     }
     var result = _typedData._getInt64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianInt64(result, endian._littleEndian);
   }
   void setInt64(int byteOffset,
                 int value,
                 [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 7 >= length) {
+      _throwRangeError(byteOffset + 7, length);
     }
     var set_value = _toInt64(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianInt64(set_value, endian._littleEndian);
     }
     _typedData._setInt64(_offset + byteOffset, set_value);
   }
 
   int getUint64(int byteOffset, [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 7 >= length) {
+      _throwRangeError(byteOffset + 7, length);
     }
     var result = _typedData._getUint64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianUint64(result, endian._littleEndian);
   }
   void setUint64(int byteOffset,
                  int value,
                  [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 7 >= length) {
+      _throwRangeError(byteOffset + 7, length);
     }
     var set_value = _toUint64(value);
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianUint64(set_value, endian._littleEndian);
     }
     _typedData._setUint64(_offset + byteOffset, set_value);
   }
 
   double getFloat32(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 3 >= length) {
+      _throwRangeError(byteOffset + 3, length);
     }
     var result = _typedData._getFloat32(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianFloat32(result, endian._littleEndian);
   }
   void setFloat32(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 3 >= length) {
+      _throwRangeError(byteOffset + 3, length);
     }
     var set_value = value;
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianFloat32(set_value, endian._littleEndian);
     }
     _typedData._setFloat32(_offset + byteOffset, set_value);
   }
 
   double getFloat64(int byteOffset,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 7 >= length) {
+      _throwRangeError(byteOffset + 7, length);
     }
     var result = _typedData._getFloat64(_offset + byteOffset);
     if (identical(endian, Endianness.HOST_ENDIAN)) {
       return result;
     }
     return _toEndianFloat64(result, endian._littleEndian);
   }
   void setFloat64(int byteOffset,
                   double value,
                   [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 7 >= length) {
+      _throwRangeError(byteOffset + 7, length);
     }
     var set_value = value;
     if (!identical(endian, Endianness.HOST_ENDIAN)) {
       set_value = _toEndianFloat64(set_value, endian._littleEndian);
     }
     _typedData._setFloat64(_offset + byteOffset, set_value);
   }
 
   Float32x4 getFloat32x4(int byteOffset,
                          [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 3 >= length) {
+      _throwRangeError(byteOffset + 3, length);
     }
     // TODO(johnmccutchan) : Need to resolve this for endianity.
     return _typedData._getFloat32x4(_offset + byteOffset);
   }
   void setFloat32x4(int byteOffset,
                     Float32x4 value,
                     [Endianness endian = Endianness.BIG_ENDIAN]) {
-    if (byteOffset < 0 || byteOffset >= length) {
-      _throwRangeError(byteOffset, length);
+    if (byteOffset < 0 || byteOffset + 3 >= length) {
+      _throwRangeError(byteOffset + 3, length);
     }
     // TODO(johnmccutchan) : Need to resolve this for endianity.
     _typedData._setFloat32x4(_offset + byteOffset, value);
 
   }
 
 
   // Internal utility methods.
 
   static int _toEndianInt16(int host_value, bool little_endian)
@@ skipping 93 matching lines @@
     return value;
   }
   return object;
 }
 
 
 void _throwRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
   throw new RangeError(message);
 }