s/transferrable/transferable

runtime/lib/byte_array.dart

 // Copyright (c) 2012, 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 class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
 
-  /* patch */ factory Int8List.transferrable(int length) {
-    return new _Int8Array.transferrable(length);
+  /* patch */ factory Int8List.transferable(int length) {
+    return new _Int8Array.transferable(length);
   }
 
   /* patch */ factory Int8List.view(ByteArray array,
                                     [int start = 0, int length]) {
     return new _Int8ArrayView(array, start, length);
   }
 }
 
 
 patch class Uint8List {
   /* patch */ factory Uint8List(int length) {
     return new _Uint8Array(length);
   }
 
-  /* patch */ factory Uint8List.transferrable(int length) {
-    return new _Uint8Array.transferrable(length);
+  /* patch */ factory Uint8List.transferable(int length) {
+    return new _Uint8Array.transferable(length);
   }
 
   /* patch */ factory Uint8List.view(ByteArray array,
                                      [int start = 0, int length]) {
     return new _Uint8ArrayView(array, start, length);
   }
 }
 
 
 patch class Int16List {
   /* patch */ factory Int16List(int length) {
     return new _Int16Array(length);
   }
 
-  /* patch */ factory Int16List.transferrable(int length) {
-    return new _Int16Array.transferrable(length);
+  /* patch */ factory Int16List.transferable(int length) {
+    return new _Int16Array.transferable(length);
   }
 
   /* patch */ factory Int16List.view(ByteArray array, [int start = 0, int length]) {
     return new _Int16ArrayView(array, start, length);
   }
 }
 
 
 patch class Uint16List {
   /* patch */ factory Uint16List(int length) {
     return new _Uint16Array(length);
   }
 
-  /* patch */ factory Uint16List.transferrable(int length) {
-    return new _Uint16Array.transferrable(length);
+  /* patch */ factory Uint16List.transferable(int length) {
+    return new _Uint16Array.transferable(length);
   }
 
   /* patch */ factory Uint16List.view(ByteArray array, [int start = 0, int length]) {
     return new _Uint16ArrayView(array, start, length);
   }
 }
 
 
 patch class Int32List {
   /* patch */ factory Int32List(int length) {
     return new _Int32Array(length);
   }
 
-  /* patch */ factory Int32List.transferrable(int length) {
-    return new _Int32Array.transferrable(length);
+  /* patch */ factory Int32List.transferable(int length) {
+    return new _Int32Array.transferable(length);
   }
 
   /* patch */ factory Int32List.view(ByteArray array, [int start = 0, int length]) {
     return new _Int32ArrayView(array, start, length);
   }
 }
 
 
 patch class Uint32List {
   /* patch */ factory Uint32List(int length) {
     return new _Uint32Array(length);
   }
 
-  /* patch */ factory Uint32List.transferrable(int length) {
-    return new _Uint32Array.transferrable(length);
+  /* patch */ factory Uint32List.transferable(int length) {
+    return new _Uint32Array.transferable(length);
   }
 
   /* patch */ factory Uint32List.view(ByteArray array, [int start = 0, int length]) {
     return new _Uint32ArrayView(array, start, length);
   }
 }
 
 
 patch class Int64List {
   /* patch */ factory Int64List(int length) {
     return new _Int64Array(length);
   }
 
-  /* patch */ factory Int64List.transferrable(int length) {
-    return new _Int64Array.transferrable(length);
+  /* patch */ factory Int64List.transferable(int length) {
+    return new _Int64Array.transferable(length);
   }
 
   /* patch */ factory Int64List.view(ByteArray array, [int start = 0, int length]) {
     return new _Int64ArrayView(array, start, length);
   }
 }
 
 
 patch class Uint64List {
   /* patch */ factory Uint64List(int length) {
     return new _Uint64Array(length);
   }
 
-  /* patch */ factory Uint64List.transferrable(int length) {
-    return new _Uint64Array.transferrable(length);
+  /* patch */ factory Uint64List.transferable(int length) {
+    return new _Uint64Array.transferable(length);
   }
 
   /* patch */ factory Uint64List.view(ByteArray array, [int start = 0, int length]) {
     return new _Uint64ArrayView(array, start, length);
   }
 }
 
 
 patch class Float32List {
   /* patch */ factory Float32List(int length) {
     return new _Float32Array(length);
   }
 
-  /* patch */ factory Float32List.transferrable(int length) {
-    return new _Float32Array.transferrable(length);
+  /* patch */ factory Float32List.transferable(int length) {
+    return new _Float32Array.transferable(length);
   }
 
   /* patch */ factory Float32List.view(ByteArray array, [int start = 0, int length]) {
     return new _Float32ArrayView(array, start, length);
   }
 }
 
 
 patch class Float64List {
   /* patch */ factory Float64List(int length) {
     return new _Float64Array(length);
   }
 
-  /* patch */ factory Float64List.transferrable(int length) {
-    return new _Float64Array.transferrable(length);
+  /* patch */ factory Float64List.transferable(int length) {
+    return new _Float64Array.transferable(length);
   }
 
   /* patch */ factory Float64List.view(ByteArray array, [int start = 0, int length]) {
     return new _Float64ArrayView(array, start, length);
   }
 }
 
 
 abstract class _ByteArrayBase {
   int lengthInBytes();
@@ skipping 221 matching lines @@
   }
   throw new ArgumentError("$object is not an integer or null");
 }
 
 
 class _Int8Array extends _ByteArrayBase implements Int8List {
   factory _Int8Array(int length) {
     return _new(length);
   }
 
-  factory _Int8Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Int8Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Int8Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = array.lengthInBytes();
     }
     return new _Int8ArrayView(array, start, length);
   }
 
   int operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 1;
 
   static _Int8Array _new(int length) native "Int8Array_new";
-  static _Int8Array _newTransferrable(int length)
-      native "Int8Array_newTransferrable";
+  static _Int8Array _newTransferable(int length)
+      native "Int8Array_newTransferable";
       
 
   int _getIndexed(int index) native "Int8Array_getIndexed";
   int _setIndexed(int index, int value) native "Int8Array_setIndexed";
 }
 
 
 class _Uint8Array extends _ByteArrayBase implements Uint8List {
   factory _Uint8Array(int length) {
     return _new(length);
   }
 
-  factory _Uint8Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Uint8Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Uint8Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = array.lengthInBytes();
     }
     return new _Uint8ArrayView(array, start, length);
   }
 
   int operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 1;
 
   static _Uint8Array _new(int length) native "Uint8Array_new";
-  static _Uint8Array _newTransferrable(int length) 
-      native "Uint8Array_newTransferrable";
+  static _Uint8Array _newTransferable(int length) 
+      native "Uint8Array_newTransferable";
       
   int _getIndexed(int index) native "Uint8Array_getIndexed";
   int _setIndexed(int index, int value) native "Uint8Array_setIndexed";
 }
 
 
 class _Int16Array extends _ByteArrayBase implements Int16List {
   factory _Int16Array(int length) {
     return _new(length);
   }
 
-  factory _Int16Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Int16Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Int16Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Int16ArrayView(array, start, length);
   }
 
   int operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 2;
 
   static _Int16Array _new(int length) native "Int16Array_new";
-  static _Int16Array _newTransferrable(int length)
-      native "Int16Array_newTransferrable";
+  static _Int16Array _newTransferable(int length)
+      native "Int16Array_newTransferable";
 
   int _getIndexed(int index) native "Int16Array_getIndexed";
   int _setIndexed(int index, int value) native "Int16Array_setIndexed";
 }
 
 
 class _Uint16Array extends _ByteArrayBase implements Uint16List {
   factory _Uint16Array(int length) {
     return _new(length);
   }
 
-  factory _Uint16Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Uint16Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Uint16Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Uint16ArrayView(array, start, length);
   }
 
   int operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 2;
 
   static _Uint16Array _new(int length) native "Uint16Array_new";
-  static _Uint16Array _newTransferrable(int length)
-      native "Uint16Array_newTransferrable";
+  static _Uint16Array _newTransferable(int length)
+      native "Uint16Array_newTransferable";
 
   int _getIndexed(int index) native "Uint16Array_getIndexed";
   int _setIndexed(int index, int value) native "Uint16Array_setIndexed";
 }
 
 
 class _Int32Array extends _ByteArrayBase implements Int32List {
   factory _Int32Array(int length) {
     return _new(length);
   }
 
-  factory _Int32Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Int32Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Int32Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Int32ArrayView(array, start, length);
   }
 
   int operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 4;
 
   static _Int32Array _new(int length) native "Int32Array_new";
-  static _Int32Array _newTransferrable(int length)
-      native "Int32Array_newTransferrable";
+  static _Int32Array _newTransferable(int length)
+      native "Int32Array_newTransferable";
       
 
   int _getIndexed(int index) native "Int32Array_getIndexed";
   int _setIndexed(int index, int value) native "Int32Array_setIndexed";
 }
 
 
 class _Uint32Array extends _ByteArrayBase implements Uint32List {
   factory _Uint32Array(int length) {
     return _new(length);
   }
 
-  factory _Uint32Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Uint32Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Uint32Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Uint32ArrayView(array, start, length);
   }
 
   int operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 4;
 
   static _Uint32Array _new(int length) native "Uint32Array_new";
-  static _Uint32Array _newTransferrable(int length)
-      native "Uint32Array_newTransferrable";
+  static _Uint32Array _newTransferable(int length)
+      native "Uint32Array_newTransferable";
 
   int _getIndexed(int index) native "Uint32Array_getIndexed";
   int _setIndexed(int index, int value) native "Uint32Array_setIndexed";
 }
 
 
 class _Int64Array extends _ByteArrayBase implements Int64List {
   factory _Int64Array(int length) {
     return _new(length);
   }
 
-  factory _Int64Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Int64Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Int64Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Int64ArrayView(array, start, length);
   }
 
   int operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 8;
 
   static _Int64Array _new(int length) native "Int64Array_new";
-  static _Int64Array _newTransferrable(int length)
-      native "Int64Array_newTransferrable";
+  static _Int64Array _newTransferable(int length)
+      native "Int64Array_newTransferable";
 
   int _getIndexed(int index) native "Int64Array_getIndexed";
   int _setIndexed(int index, int value) native "Int64Array_setIndexed";
 }
 
 
 class _Uint64Array extends _ByteArrayBase implements Uint64List {
   factory _Uint64Array(int length) {
     return _new(length);
   }
 
-  factory _Uint64Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Uint64Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Uint64Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Uint64ArrayView(array, start, length);
   }
 
   int operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 8;
 
   static _Uint64Array _new(int length) native "Uint64Array_new";
-  static _Uint64Array _newTransferrable(int length)
-      native "Uint64Array_newTransferrable";
+  static _Uint64Array _newTransferable(int length)
+      native "Uint64Array_newTransferable";
 
   int _getIndexed(int index) native "Uint64Array_getIndexed";
   int _setIndexed(int index, int value) native "Uint64Array_setIndexed";
 }
 
 
 class _Float32Array extends _ByteArrayBase implements Float32List {
   factory _Float32Array(int length) {
     return _new(length);
   }
 
-  factory _Float32Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Float32Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Float32Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Float32ArrayView(array, start, length);
   }
 
   double operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 4;
 
   static _Float32Array _new(int length) native "Float32Array_new";
-  static _Float32Array _newTransferrable(int length)
-      native "Float32Array_newTransferrable";
+  static _Float32Array _newTransferable(int length)
+      native "Float32Array_newTransferable";
 
   double _getIndexed(int index) native "Float32Array_getIndexed";
   int _setIndexed(int index, double value) native "Float32Array_setIndexed";
 }
 
 
 class _Float64Array extends _ByteArrayBase implements Float64List {
   factory _Float64Array(int length) {
     return _new(length);
   }
 
-  factory _Float64Array.transferrable(int length) {
-    return _newTransferrable(length);
+  factory _Float64Array.transferable(int length) {
+    return _newTransferable(length);
   }
 
   factory _Float64Array.view(ByteArray array, [int start = 0, int length]) {
     if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Float64ArrayView(array, start, length);
   }
 
   double operator[](int index) {
@@ skipping 34 matching lines @@
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 8;
 
   static _Float64Array _new(int length) native "Float64Array_new";
-  static _Float64Array _newTransferrable(int length)
-      native "Float64Array_newTransferrable";
+  static _Float64Array _newTransferable(int length)
+      native "Float64Array_newTransferable";
 
   double _getIndexed(int index) native "Float64Array_getIndexed";
   int _setIndexed(int index, double value) native "Float64Array_setIndexed";
 }
 
 
 class _ExternalInt8Array extends _ByteArrayBase implements Int8List {
   int operator[](int index) {
     return _getIndexed(index);
   }
@@ skipping 1440 matching lines @@
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const int _BYTES_PER_ELEMENT = 8;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }