Version 0.8.10.4

dart/sdk/lib/typed_data/dart2js/typed_data_dart2js.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.
 
 /**
  * Specialized integers and floating point numbers,
  * with SIMD support and efficient lists.
  */
 library dart.typed_data;
 
@@ skipping 777 matching lines @@
     _storage[(index*4)+3] = value._storage[3];
   }
 
   List<Float32x4> sublist(int start, [int end]) {
     end = _checkSublistArguments(start, end, length);
     return new Float32x4List._externalStorage(_storage.sublist(start*4, end*4));
   }
 }
 
 
-class Uint32x4List
-    extends Object with ListMixin<Uint32x4>, FixedLengthListMixin<Uint32x4>
-    implements List<Uint32x4>, TypedData {
+class Int32x4List
+    extends Object with ListMixin<Int32x4>, FixedLengthListMixin<Int32x4>
+    implements List<Int32x4>, TypedData {
 
   final Uint32List _storage;
 
   ByteBuffer get buffer => _storage.buffer;
 
   int get lengthInBytes => _storage.lengthInBytes;
 
   int get offsetInBytes => _storage.offsetInBytes;
 
   final int elementSizeInBytes = 16;
@@ skipping 17 matching lines @@
     // [length]. However, [_checkIndex] only allows indices in the range
     // 0 .. length - 1. We therefore increment the [length] argument by one
     // for the [_checkIndex] checks.
     _checkIndex(start, length + 1);
     if (end == null) return length;
     _checkIndex(end, length + 1);
     if (start > end) throw new RangeError.range(start, 0, end);
     return end;
   }
 
-  Uint32x4List(int length) : _storage = new Uint32List(length*4);
+  Int32x4List(int length) : _storage = new Uint32List(length*4);
 
-  Uint32x4List._externalStorage(Uint32List storage) : _storage = storage;
+  Int32x4List._externalStorage(Uint32List storage) : _storage = storage;
 
-  Uint32x4List._slowFromList(List<Uint32x4> list)
+  Int32x4List._slowFromList(List<Int32x4> list)
       : _storage = new Uint32List(list.length * 4) {
     for (int i = 0; i < list.length; i++) {
       var e = list[i];
       _storage[(i*4)+0] = e.x;
       _storage[(i*4)+1] = e.y;
       _storage[(i*4)+2] = e.z;
       _storage[(i*4)+3] = e.w;
     }
   }
 
-  factory Uint32x4List.fromList(List<Uint32x4> list) {
-    if (list is Uint32x4List) {
-      Uint32x4List nativeList = list as Uint32x4List;
-      return new Uint32x4List._externalStorage(
+  factory Int32x4List.fromList(List<Int32x4> list) {
+    if (list is Int32x4List) {
+      Int32x4List nativeList = list as Int32x4List;
+      return new Int32x4List._externalStorage(
           new Uint32List.fromList(nativeList._storage));
     } else {
-      return new Uint32x4List._slowFromList(list);
+      return new Int32x4List._slowFromList(list);
     }
   }
 
-  Uint32x4List.view(ByteBuffer buffer,
+  Int32x4List.view(ByteBuffer buffer,
                      [int byteOffset = 0, int length])
       : _storage = new Uint32List.view(buffer, byteOffset, length);
 
   static const int BYTES_PER_ELEMENT = 16;
 
   int get length => _storage.length ~/ 4;
 
-  Uint32x4 operator[](int index) {
+  Int32x4 operator[](int index) {
     _checkIndex(index, length);
     int _x = _storage[(index*4)+0];
     int _y = _storage[(index*4)+1];
     int _z = _storage[(index*4)+2];
     int _w = _storage[(index*4)+3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
-  void operator[]=(int index, Uint32x4 value) {
+  void operator[]=(int index, Int32x4 value) {
     _checkIndex(index, length);
     _storage[(index*4)+0] = value._storage[0];
     _storage[(index*4)+1] = value._storage[1];
     _storage[(index*4)+2] = value._storage[2];
     _storage[(index*4)+3] = value._storage[3];
   }
 
-  List<Uint32x4> sublist(int start, [int end]) {
+  List<Int32x4> sublist(int start, [int end]) {
     end = _checkSublistArguments(start, end, length);
-    return new Uint32x4List._externalStorage(_storage.sublist(start*4, end*4));
+    return new Int32x4List._externalStorage(_storage.sublist(start*4, end*4));
   }
 }
 
 
 class Float32x4 {
   final _storage = new Float32List(4);
 
   Float32x4(double x, double y, double z, double w) {
     _storage[0] = x;
     _storage[1] = y;
     _storage[2] = z;
     _storage[3] = w;
   }
   Float32x4.splat(double v) {
     _storage[0] = v;
     _storage[1] = v;
     _storage[2] = v;
     _storage[3] = v;
   }
   Float32x4.zero();
   /// Returns a bit-wise copy of [x] as a Float32x4.
-  Float32x4.fromUint32x4Bits(Uint32x4 x) {
+  Float32x4.fromInt32x4Bits(Int32x4 x) {
     var view = new Float32List.view(x._storage.buffer);
     _storage[0] = view[0];
     _storage[1] = view[1];
     _storage[2] = view[2];
     _storage[3] = view[3];
   }
 
    /// Addition operator.
   Float32x4 operator+(Float32x4 other) {
     double _x = _storage[0] + other._storage[0];
@@ skipping 33 matching lines @@
   /// Division operator.
   Float32x4 operator/(Float32x4 other) {
     double _x = _storage[0] / other._storage[0];
     double _y = _storage[1] / other._storage[1];
     double _z = _storage[2] / other._storage[2];
     double _w = _storage[3] / other._storage[3];
     return new Float32x4(_x, _y, _z, _w);
   }
 
   /// Relational less than.
-  Uint32x4 lessThan(Float32x4 other) {
+  Int32x4 lessThan(Float32x4 other) {
     bool _cx = _storage[0] < other._storage[0];
     bool _cy = _storage[1] < other._storage[1];
     bool _cz = _storage[2] < other._storage[2];
     bool _cw = _storage[3] < other._storage[3];
-    return new Uint32x4(_cx == true ? 0xFFFFFFFF : 0x0,
+    return new Int32x4(_cx == true ? 0xFFFFFFFF : 0x0,
                         _cy == true ? 0xFFFFFFFF : 0x0,
                         _cz == true ? 0xFFFFFFFF : 0x0,
                         _cw == true ? 0xFFFFFFFF : 0x0);
   }
 
   /// Relational less than or equal.
-  Uint32x4 lessThanOrEqual(Float32x4 other) {
+  Int32x4 lessThanOrEqual(Float32x4 other) {
     bool _cx = _storage[0] <= other._storage[0];
     bool _cy = _storage[1] <= other._storage[1];
     bool _cz = _storage[2] <= other._storage[2];
     bool _cw = _storage[3] <= other._storage[3];
-    return new Uint32x4(_cx == true ? 0xFFFFFFFF : 0x0,
+    return new Int32x4(_cx == true ? 0xFFFFFFFF : 0x0,
                         _cy == true ? 0xFFFFFFFF : 0x0,
                         _cz == true ? 0xFFFFFFFF : 0x0,
                         _cw == true ? 0xFFFFFFFF : 0x0);
   }
 
   /// Relational greater than.
-  Uint32x4 greaterThan(Float32x4 other) {
+  Int32x4 greaterThan(Float32x4 other) {
     bool _cx = _storage[0] > other._storage[0];
     bool _cy = _storage[1] > other._storage[1];
     bool _cz = _storage[2] > other._storage[2];
     bool _cw = _storage[3] > other._storage[3];
-    return new Uint32x4(_cx == true ? 0xFFFFFFFF : 0x0,
+    return new Int32x4(_cx == true ? 0xFFFFFFFF : 0x0,
                         _cy == true ? 0xFFFFFFFF : 0x0,
                         _cz == true ? 0xFFFFFFFF : 0x0,
                         _cw == true ? 0xFFFFFFFF : 0x0);
   }
 
   /// Relational greater than or equal.
-  Uint32x4 greaterThanOrEqual(Float32x4 other) {
+  Int32x4 greaterThanOrEqual(Float32x4 other) {
     bool _cx = _storage[0] >= other._storage[0];
     bool _cy = _storage[1] >= other._storage[1];
     bool _cz = _storage[2] >= other._storage[2];
     bool _cw = _storage[3] >= other._storage[3];
-    return new Uint32x4(_cx == true ? 0xFFFFFFFF : 0x0,
+    return new Int32x4(_cx == true ? 0xFFFFFFFF : 0x0,
                         _cy == true ? 0xFFFFFFFF : 0x0,
                         _cz == true ? 0xFFFFFFFF : 0x0,
                         _cw == true ? 0xFFFFFFFF : 0x0);
   }
 
   /// Relational equal.
-  Uint32x4 equal(Float32x4 other) {
+  Int32x4 equal(Float32x4 other) {
     bool _cx = _storage[0] == other._storage[0];
     bool _cy = _storage[1] == other._storage[1];
     bool _cz = _storage[2] == other._storage[2];
     bool _cw = _storage[3] == other._storage[3];
-    return new Uint32x4(_cx == true ? 0xFFFFFFFF : 0x0,
+    return new Int32x4(_cx == true ? 0xFFFFFFFF : 0x0,
                         _cy == true ? 0xFFFFFFFF : 0x0,
                         _cz == true ? 0xFFFFFFFF : 0x0,
                         _cw == true ? 0xFFFFFFFF : 0x0);
   }
 
   /// Relational not-equal.
-  Uint32x4 notEqual(Float32x4 other) {
+  Int32x4 notEqual(Float32x4 other) {
     bool _cx = _storage[0] != other._storage[0];
     bool _cy = _storage[1] != other._storage[1];
     bool _cz = _storage[2] != other._storage[2];
     bool _cw = _storage[3] != other._storage[3];
-    return new Uint32x4(_cx == true ? 0xFFFFFFFF : 0x0,
+    return new Int32x4(_cx == true ? 0xFFFFFFFF : 0x0,
                         _cy == true ? 0xFFFFFFFF : 0x0,
                         _cz == true ? 0xFFFFFFFF : 0x0,
                         _cw == true ? 0xFFFFFFFF : 0x0);
   }
 
   /// Returns a copy of [this] each lane being scaled by [s].
   Float32x4 scale(double s) {
     double _x = s * _storage[0];
     double _y = s * _storage[1];
     double _z = s * _storage[2];
@@ skipping 423 matching lines @@
   Float32x4 reciprocalSqrt() {
     double _x = Math.sqrt(1.0 / _storage[0]);
     double _y = Math.sqrt(1.0 / _storage[1]);
     double _z = Math.sqrt(1.0 / _storage[2]);
     double _w = Math.sqrt(1.0 / _storage[3]);
     return new Float32x4(_x, _y, _z, _w);
   }
 }
 
 
-class Uint32x4 {
-  final _storage = new Uint32List(4);
+class Int32x4 {
+  final _storage = new Int32List(4);
 
-  Uint32x4(int x, int y, int z, int w) {
+  Int32x4(int x, int y, int z, int w) {
     _storage[0] = x;
     _storage[1] = y;
     _storage[2] = z;
     _storage[3] = w;
   }
 
-  Uint32x4.bool(bool x, bool y, bool z, bool w) {
+  Int32x4.bool(bool x, bool y, bool z, bool w) {
     _storage[0] = x == true ? 0xFFFFFFFF : 0x0;
     _storage[1] = y == true ? 0xFFFFFFFF : 0x0;
     _storage[2] = z == true ? 0xFFFFFFFF : 0x0;
     _storage[3] = w == true ? 0xFFFFFFFF : 0x0;
   }
 
-  /// Returns a bit-wise copy of [x] as a Uint32x4.
-  Uint32x4.fromFloat32x4Bits(Float32x4 x) {
+  /// Returns a bit-wise copy of [x] as a Int32x4.
+  Int32x4.fromFloat32x4Bits(Float32x4 x) {
     var view = new Uint32List.view(x._storage.buffer);
     _storage[0] = view[0];
     _storage[1] = view[1];
     _storage[2] = view[2];
     _storage[3] = view[3];
   }
 
   /// The bit-wise or operator.
-  Uint32x4 operator|(Uint32x4 other) {
+  Int32x4 operator|(Int32x4 other) {
     int _x = _storage[0] | other._storage[0];
     int _y = _storage[1] | other._storage[1];
     int _z = _storage[2] | other._storage[2];
     int _w = _storage[3] | other._storage[3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
   /// The bit-wise and operator.
-  Uint32x4 operator&(Uint32x4 other) {
+  Int32x4 operator&(Int32x4 other) {
     int _x = _storage[0] & other._storage[0];
     int _y = _storage[1] & other._storage[1];
     int _z = _storage[2] & other._storage[2];
     int _w = _storage[3] & other._storage[3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
   /// The bit-wise xor operator.
-  Uint32x4 operator^(Uint32x4 other) {
+  Int32x4 operator^(Int32x4 other) {
     int _x = _storage[0] ^ other._storage[0];
     int _y = _storage[1] ^ other._storage[1];
     int _z = _storage[2] ^ other._storage[2];
     int _w = _storage[3] ^ other._storage[3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
-  Uint32x4 operator+(Uint32x4 other) {
-    var r = new Uint32x4(0, 0, 0, 0);
+  Int32x4 operator+(Int32x4 other) {
+    var r = new Int32x4(0, 0, 0, 0);
     r._storage[0] = (_storage[0] + other._storage[0]);
     r._storage[1] = (_storage[1] + other._storage[1]);
     r._storage[2] = (_storage[2] + other._storage[2]);
     r._storage[3] = (_storage[3] + other._storage[3]);
     return r;
   }
 
-  Uint32x4 operator-(Uint32x4 other) {
-    var r = new Uint32x4(0, 0, 0, 0);
+  Int32x4 operator-(Int32x4 other) {
+    var r = new Int32x4(0, 0, 0, 0);
     r._storage[0] = (_storage[0] - other._storage[0]);
     r._storage[1] = (_storage[1] - other._storage[1]);
     r._storage[2] = (_storage[2] - other._storage[2]);
     r._storage[3] = (_storage[3] - other._storage[3]);
     return r;
   }
 
   /// Extract 32-bit mask from x lane.
   int get x => _storage[0];
   /// Extract 32-bit mask from y lane.
@@ skipping 264 matching lines @@
   static const int WWZX = 0x2F;
   static const int WWZY = 0x6F;
   static const int WWZZ = 0xAF;
   static const int WWZW = 0xEF;
   static const int WWWX = 0x3F;
   static const int WWWY = 0x7F;
   static const int WWWZ = 0xBF;
   static const int WWWW = 0xFF;
 
   /// Shuffle the lane values. [mask] must be one of the 256 shuffle constants.
-  Uint32x4 shuffle(int mask) {
+  Int32x4 shuffle(int mask) {
     if ((mask < 0) || (mask > 255)) {
       throw new RangeError('mask $mask must be in the range [0..256)');
     }
     int _x = _storage[mask & 0x3];
     int _y = _storage[(mask >> 2) & 0x3];
     int _z = _storage[(mask >> 4) & 0x3];
     int _w = _storage[(mask >> 6) & 0x3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
   /// Shuffle the lane values in [this] and [other]. The returned
-  /// Uint32x4 will have XY lanes from [this] and ZW lanes from [other].
+  /// Int32x4 will have XY lanes from [this] and ZW lanes from [other].
   /// Uses the same [mask] as [shuffle].
-  Uint32x4 shuffleMix(Uint32x4 other, int mask) {
+  Int32x4 shuffleMix(Int32x4 other, int mask) {
     if ((mask < 0) || (mask > 255)) {
       throw new RangeError('mask $mask must be in the range [0..256)');
     }
     int _x = _storage[mask & 0x3];
     int _y = _storage[(mask >> 2) & 0x3];
     int _z = other._storage[(mask >> 4) & 0x3];
     int _w = other._storage[(mask >> 6) & 0x3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
-  /// Returns a new [Uint32x4] copied from [this] with a new x value.
-  Uint32x4 withX(int x) {
+  /// Returns a new [Int32x4] copied from [this] with a new x value.
+  Int32x4 withX(int x) {
     int _x = x;
     int _y = _storage[1];
     int _z = _storage[2];
     int _w = _storage[3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
-  /// Returns a new [Uint32x4] copied from [this] with a new y value.
-  Uint32x4 withY(int y) {
+  /// Returns a new [Int32x4] copied from [this] with a new y value.
+  Int32x4 withY(int y) {
     int _x = _storage[0];
     int _y = y;
     int _z = _storage[2];
     int _w = _storage[3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
-  /// Returns a new [Uint32x4] copied from [this] with a new z value.
-  Uint32x4 withZ(int z) {
+  /// Returns a new [Int32x4] copied from [this] with a new z value.
+  Int32x4 withZ(int z) {
     int _x = _storage[0];
     int _y = _storage[1];
     int _z = z;
     int _w = _storage[3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
-  /// Returns a new [Uint32x4] copied from [this] with a new w value.
-  Uint32x4 withW(int w) {
+  /// Returns a new [Int32x4] copied from [this] with a new w value.
+  Int32x4 withW(int w) {
     int _x = _storage[0];
     int _y = _storage[1];
     int _z = _storage[2];
     int _w = w;
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
   /// Extracted x value. Returns false for 0, true for any other value.
   bool get flagX => _storage[0] != 0x0;
   /// Extracted y value. Returns false for 0, true for any other value.
   bool get flagY => _storage[1] != 0x0;
   /// Extracted z value. Returns false for 0, true for any other value.
   bool get flagZ => _storage[2] != 0x0;
   /// Extracted w value. Returns false for 0, true for any other value.
   bool get flagW => _storage[3] != 0x0;
 
-  /// Returns a new [Uint32x4] copied from [this] with a new x value.
-  Uint32x4 withFlagX(bool x) {
+  /// Returns a new [Int32x4] copied from [this] with a new x value.
+  Int32x4 withFlagX(bool x) {
     int _x = x == true ? 0xFFFFFFFF : 0x0;
     int _y = _storage[1];
     int _z = _storage[2];
     int _w = _storage[3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
-  /// Returns a new [Uint32x4] copied from [this] with a new y value.
-  Uint32x4 withFlagY(bool y) {
+  /// Returns a new [Int32x4] copied from [this] with a new y value.
+  Int32x4 withFlagY(bool y) {
     int _x = _storage[0];
     int _y = y == true ? 0xFFFFFFFF : 0x0;
     int _z = _storage[2];
     int _w = _storage[3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
-  /// Returns a new [Uint32x4] copied from [this] with a new z value.
-  Uint32x4 withFlagZ(bool z) {
+  /// Returns a new [Int32x4] copied from [this] with a new z value.
+  Int32x4 withFlagZ(bool z) {
     int _x = _storage[0];
     int _y = _storage[1];
     int _z = z == true ? 0xFFFFFFFF : 0x0;
     int _w = _storage[3];
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
-  /// Returns a new [Uint32x4] copied from [this] with a new w value.
-  Uint32x4 withFlagW(bool w) {
+  /// Returns a new [Int32x4] copied from [this] with a new w value.
+  Int32x4 withFlagW(bool w) {
     int _x = _storage[0];
     int _y = _storage[1];
     int _z = _storage[2];
     int _w = w == true ? 0xFFFFFFFF : 0x0;
-    return new Uint32x4(_x, _y, _z, _w);
+    return new Int32x4(_x, _y, _z, _w);
   }
 
   /// Merge [trueValue] and [falseValue] based on [this]' bit mask:
   /// Select bit from [trueValue] when bit in [this] is on.
   /// Select bit from [falseValue] when bit in [this] is off.
   Float32x4 select(Float32x4 trueValue, Float32x4 falseValue) {
-    var trueView = new Uint32List.view(trueValue._storage.buffer);
-    var falseView = new Uint32List.view(falseValue._storage.buffer);
+    var trueView = new Int32List.view(trueValue._storage.buffer);
+    var falseView = new Int32List.view(falseValue._storage.buffer);
     int cmx = _storage[0];
     int cmy = _storage[1];
     int cmz = _storage[2];
     int cmw = _storage[3];
     int stx = trueView[0];
     int sty = trueView[1];
     int stz = trueView[2];
     int stw = trueView[3];
     int sfx = falseView[0];
     int sfy = falseView[1];
     int sfz = falseView[2];
     int sfw = falseView[3];
     int _x = (cmx & stx) | (~cmx & sfx);
     int _y = (cmy & sty) | (~cmy & sfy);
     int _z = (cmz & stz) | (~cmz & sfz);
     int _w = (cmw & stw) | (~cmw & sfw);
     var r = new Float32x4(0.0, 0.0, 0.0, 0.0);
-    var rView = new Uint32List.view(r._storage.buffer);
+    var rView = new Int32List.view(r._storage.buffer);
     rView[0] = _x;
     rView[1] = _y;
     rView[2] = _z;
     rView[3] = _w;
     return r;
   }
 }