Mercurial > jdk8-mips64-public > nashorn / changeset

     1.1 --- a/src/jdk/nashorn/internal/codegen/FieldObjectCreator.java	Thu Jun 06 21:41:20 2013 +0530
     1.2 +++ b/src/jdk/nashorn/internal/codegen/FieldObjectCreator.java	Fri Jun 07 17:44:25 2013 +0200
     1.3 @@ -126,7 +126,7 @@
     1.4              final T      value  = valueIter.next();
     1.5  
     1.6              if (symbol != null && value != null) {
     1.7 -                final int index = ArrayIndex.getArrayIndexNoThrow(key);
     1.8 +                final int index = ArrayIndex.getArrayIndex(key);
     1.9  
    1.10                  if (index < 0) {
    1.11                      putField(method, key, symbol.getFieldIndex(), value);

     2.1 --- a/src/jdk/nashorn/internal/codegen/MapCreator.java	Thu Jun 06 21:41:20 2013 +0530
     2.2 +++ b/src/jdk/nashorn/internal/codegen/MapCreator.java	Fri Jun 07 17:44:25 2013 +0200
     2.3 @@ -79,7 +79,7 @@
     2.4              final String key    = keys[i];
     2.5              final Symbol symbol = symbols[i];
     2.6  
     2.7 -            if (symbol != null && !ArrayIndex.isIndexKey(key)) {
     2.8 +            if (symbol != null && !ArrayIndex.isIntArrayIndex(key)) {
     2.9                  properties.add(new AccessorProperty(key, getPropertyFlags(symbol, hasArguments), structure, symbol.getFieldIndex()));
    2.10              }
    2.11          }

     3.1 --- a/src/jdk/nashorn/internal/objects/ArrayBufferView.java	Thu Jun 06 21:41:20 2013 +0530
     3.2 +++ b/src/jdk/nashorn/internal/objects/ArrayBufferView.java	Fri Jun 07 17:44:25 2013 +0200
     3.3 @@ -33,6 +33,8 @@
     3.4  import jdk.nashorn.internal.runtime.ScriptRuntime;
     3.5  import jdk.nashorn.internal.runtime.arrays.ArrayData;
     3.6  
     3.7 +import static jdk.nashorn.internal.runtime.ECMAErrors.rangeError;
     3.8 +
     3.9  @ScriptClass("ArrayBufferView")
    3.10  abstract class ArrayBufferView extends ScriptObject {
    3.11  
    3.12 @@ -305,11 +307,11 @@
    3.13              dst = factory.construct(length);
    3.14          } else if (arg0 instanceof NativeArray) {
    3.15              // Constructor(type[] array)
    3.16 -            length = (int) (((NativeArray) arg0).getArray().length() & 0x7fff_ffff);
    3.17 +            length = lengthToInt(((NativeArray) arg0).getArray().length());
    3.18              dst = factory.construct(length);
    3.19          } else {
    3.20              // Constructor(unsigned long length)
    3.21 -            length = JSType.toInt32(arg0);
    3.22 +            length = lengthToInt(JSType.toInt64(arg0));
    3.23              return factory.construct(length);
    3.24          }
    3.25  
    3.26 @@ -354,6 +356,13 @@
    3.27          }
    3.28      }
    3.29  
    3.30 +    private static int lengthToInt(final long length) {
    3.31 +        if (length > Integer.MAX_VALUE || length < 0) {
    3.32 +            throw rangeError("inappropriate.array.buffer.length", JSType.toString(length));
    3.33 +        }
    3.34 +        return (int) (length & Integer.MAX_VALUE);
    3.35 +    }
    3.36 +
    3.37      protected static Object subarrayImpl(final Object self, final Object begin0, final Object end0) {
    3.38          final ArrayBufferView arrayView = ((ArrayBufferView)self);
    3.39          final int elementLength = arrayView.elementLength();

     4.1 --- a/src/jdk/nashorn/internal/objects/NativeArguments.java	Thu Jun 06 21:41:20 2013 +0530
     4.2 +++ b/src/jdk/nashorn/internal/objects/NativeArguments.java	Fri Jun 07 17:44:25 2013 +0200
     4.3 @@ -27,7 +27,6 @@
     4.4  
     4.5  import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
     4.6  import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
     4.7 -import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.getArrayIndexNoThrow;
     4.8  import static jdk.nashorn.internal.lookup.Lookup.MH;
     4.9  
    4.10  import java.lang.invoke.MethodHandle;
    4.11 @@ -132,103 +131,103 @@
    4.12  
    4.13      @Override
    4.14      public int getInt(final Object key) {
    4.15 -        final int index = getArrayIndexNoThrow(key);
    4.16 +        final int index = ArrayIndex.getArrayIndex(key);
    4.17          return isMapped(index) ? namedArgs.getInt(index) : super.getInt(key);
    4.18      }
    4.19  
    4.20      @Override
    4.21      public int getInt(final double key) {
    4.22 -        final int index = getArrayIndexNoThrow(key);
    4.23 +        final int index = ArrayIndex.getArrayIndex(key);
    4.24          return isMapped(index) ? namedArgs.getInt(index) : super.getInt(key);
    4.25      }
    4.26  
    4.27      @Override
    4.28      public int getInt(final long key) {
    4.29 -        final int index = getArrayIndexNoThrow(key);
    4.30 +        final int index = ArrayIndex.getArrayIndex(key);
    4.31          return isMapped(index) ? namedArgs.getInt(index) : super.getInt(key);
    4.32      }
    4.33  
    4.34      @Override
    4.35      public int getInt(final int key) {
    4.36 -        final int index = getArrayIndexNoThrow(key);
    4.37 +        final int index = ArrayIndex.getArrayIndex(key);
    4.38          return isMapped(index) ? namedArgs.getInt(index) : super.getInt(key);
    4.39      }
    4.40  
    4.41      @Override
    4.42      public long getLong(final Object key) {
    4.43 -        final int index = getArrayIndexNoThrow(key);
    4.44 +        final int index = ArrayIndex.getArrayIndex(key);
    4.45          return isMapped(index) ? namedArgs.getLong(index) : super.getLong(key);
    4.46      }
    4.47  
    4.48      @Override
    4.49      public long getLong(final double key) {
    4.50 -        final int index = getArrayIndexNoThrow(key);
    4.51 +        final int index = ArrayIndex.getArrayIndex(key);
    4.52          return isMapped(index) ? namedArgs.getLong(index) : super.getLong(key);
    4.53      }
    4.54  
    4.55      @Override
    4.56      public long getLong(final long key) {
    4.57 -        final int index = getArrayIndexNoThrow(key);
    4.58 +        final int index = ArrayIndex.getArrayIndex(key);
    4.59          return isMapped(index) ? namedArgs.getLong(index) : super.getLong(key);
    4.60      }
    4.61  
    4.62      @Override
    4.63      public long getLong(final int key) {
    4.64 -        final int index = getArrayIndexNoThrow(key);
    4.65 +        final int index = ArrayIndex.getArrayIndex(key);
    4.66          return isMapped(index) ? namedArgs.getLong(index) : super.getLong(key);
    4.67      }
    4.68  
    4.69      @Override
    4.70      public double getDouble(final Object key) {
    4.71 -        final int index = getArrayIndexNoThrow(key);
    4.72 +        final int index = ArrayIndex.getArrayIndex(key);
    4.73          return isMapped(index) ? namedArgs.getDouble(index) : super.getDouble(key);
    4.74      }
    4.75  
    4.76      @Override
    4.77      public double getDouble(final double key) {
    4.78 -        final int index = getArrayIndexNoThrow(key);
    4.79 +        final int index = ArrayIndex.getArrayIndex(key);
    4.80          return isMapped(index) ? namedArgs.getDouble(index) : super.getDouble(key);
    4.81      }
    4.82  
    4.83      @Override
    4.84      public double getDouble(final long key) {
    4.85 -        final int index = getArrayIndexNoThrow(key);
    4.86 +        final int index = ArrayIndex.getArrayIndex(key);
    4.87          return isMapped(index) ? namedArgs.getDouble(index) : super.getDouble(key);
    4.88      }
    4.89  
    4.90      @Override
    4.91      public double getDouble(final int key) {
    4.92 -        final int index = getArrayIndexNoThrow(key);
    4.93 +        final int index = ArrayIndex.getArrayIndex(key);
    4.94          return isMapped(index) ? namedArgs.getDouble(index) : super.getDouble(key);
    4.95      }
    4.96  
    4.97      @Override
    4.98      public Object get(final Object key) {
    4.99 -        final int index = getArrayIndexNoThrow(key);
   4.100 +        final int index = ArrayIndex.getArrayIndex(key);
   4.101          return isMapped(index) ? namedArgs.getObject(index) : super.get(key);
   4.102      }
   4.103  
   4.104      @Override
   4.105      public Object get(final double key) {
   4.106 -        final int index = getArrayIndexNoThrow(key);
   4.107 +        final int index = ArrayIndex.getArrayIndex(key);
   4.108          return isMapped(index) ? namedArgs.getObject(index) : super.get(key);
   4.109      }
   4.110  
   4.111      @Override
   4.112      public Object get(final long key) {
   4.113 -        final int index = getArrayIndexNoThrow(key);
   4.114 +        final int index = ArrayIndex.getArrayIndex(key);
   4.115          return isMapped(index) ? namedArgs.getObject(index) : super.get(key);
   4.116      }
   4.117  
   4.118      @Override
   4.119      public Object get(final int key) {
   4.120 -        final int index = getArrayIndexNoThrow(key);
   4.121 +        final int index = ArrayIndex.getArrayIndex(key);
   4.122          return isMapped(index) ? namedArgs.getObject(index) : super.get(key);
   4.123      }
   4.124  
   4.125      @Override
   4.126      public void set(final Object key, final int value, final boolean strict) {
   4.127 -        final int index = getArrayIndexNoThrow(key);
   4.128 +        final int index = ArrayIndex.getArrayIndex(key);
   4.129          if (isMapped(index)) {
   4.130              namedArgs = namedArgs.set(index, value, strict);
   4.131          } else {
   4.132 @@ -238,7 +237,7 @@
   4.133  
   4.134      @Override
   4.135      public void set(final Object key, final long value, final boolean strict) {
   4.136 -        final int index = getArrayIndexNoThrow(key);
   4.137 +        final int index = ArrayIndex.getArrayIndex(key);
   4.138          if (isMapped(index)) {
   4.139              namedArgs = namedArgs.set(index, value, strict);
   4.140          } else {
   4.141 @@ -248,7 +247,7 @@
   4.142  
   4.143      @Override
   4.144      public void set(final Object key, final double value, final boolean strict) {
   4.145 -        final int index = getArrayIndexNoThrow(key);
   4.146 +        final int index = ArrayIndex.getArrayIndex(key);
   4.147          if (isMapped(index)) {
   4.148              namedArgs = namedArgs.set(index, value, strict);
   4.149          } else {
   4.150 @@ -258,7 +257,7 @@
   4.151  
   4.152      @Override
   4.153      public void set(final Object key, final Object value, final boolean strict) {
   4.154 -        final int index = getArrayIndexNoThrow(key);
   4.155 +        final int index = ArrayIndex.getArrayIndex(key);
   4.156          if (isMapped(index)) {
   4.157              namedArgs = namedArgs.set(index, value, strict);
   4.158          } else {
   4.159 @@ -268,7 +267,7 @@
   4.160  
   4.161      @Override
   4.162      public void set(final double key, final int value, final boolean strict) {
   4.163 -        final int index = getArrayIndexNoThrow(key);
   4.164 +        final int index = ArrayIndex.getArrayIndex(key);
   4.165          if (isMapped(index)) {
   4.166              namedArgs = namedArgs.set(index, value, strict);
   4.167          } else {
   4.168 @@ -278,7 +277,7 @@
   4.169  
   4.170      @Override
   4.171      public void set(final double key, final long value, final boolean strict) {
   4.172 -        final int index = getArrayIndexNoThrow(key);
   4.173 +        final int index = ArrayIndex.getArrayIndex(key);
   4.174          if (isMapped(index)) {
   4.175              namedArgs = namedArgs.set(index, value, strict);
   4.176          } else {
   4.177 @@ -288,7 +287,7 @@
   4.178  
   4.179      @Override
   4.180      public void set(final double key, final double value, final boolean strict) {
   4.181 -        final int index = getArrayIndexNoThrow(key);
   4.182 +        final int index = ArrayIndex.getArrayIndex(key);
   4.183          if (isMapped(index)) {
   4.184              namedArgs = namedArgs.set(index, value, strict);
   4.185          } else {
   4.186 @@ -298,7 +297,7 @@
   4.187  
   4.188      @Override
   4.189      public void set(final double key, final Object value, final boolean strict) {
   4.190 -        final int index = getArrayIndexNoThrow(key);
   4.191 +        final int index = ArrayIndex.getArrayIndex(key);
   4.192          if (isMapped(index)) {
   4.193              namedArgs = namedArgs.set(index, value, strict);
   4.194          } else {
   4.195 @@ -308,7 +307,7 @@
   4.196  
   4.197      @Override
   4.198      public void set(final long key, final int value, final boolean strict) {
   4.199 -        final int index = getArrayIndexNoThrow(key);
   4.200 +        final int index = ArrayIndex.getArrayIndex(key);
   4.201          if (isMapped(index)) {
   4.202              namedArgs = namedArgs.set(index, value, strict);
   4.203          } else {
   4.204 @@ -318,7 +317,7 @@
   4.205  
   4.206      @Override
   4.207      public void set(final long key, final long value, final boolean strict) {
   4.208 -        final int index = getArrayIndexNoThrow(key);
   4.209 +        final int index = ArrayIndex.getArrayIndex(key);
   4.210          if (isMapped(index)) {
   4.211              namedArgs = namedArgs.set(index, value, strict);
   4.212          } else {
   4.213 @@ -328,7 +327,7 @@
   4.214  
   4.215      @Override
   4.216      public void set(final long key, final double value, final boolean strict) {
   4.217 -        final int index = getArrayIndexNoThrow(key);
   4.218 +        final int index = ArrayIndex.getArrayIndex(key);
   4.219          if (isMapped(index)) {
   4.220              namedArgs = namedArgs.set(index, value, strict);
   4.221          } else {
   4.222 @@ -338,7 +337,7 @@
   4.223  
   4.224      @Override
   4.225      public void set(final long key, final Object value, final boolean strict) {
   4.226 -        final int index = getArrayIndexNoThrow(key);
   4.227 +        final int index = ArrayIndex.getArrayIndex(key);
   4.228          if (isMapped(index)) {
   4.229              namedArgs = namedArgs.set(index, value, strict);
   4.230          } else {
   4.231 @@ -348,7 +347,7 @@
   4.232  
   4.233      @Override
   4.234      public void set(final int key, final int value, final boolean strict) {
   4.235 -        final int index = getArrayIndexNoThrow(key);
   4.236 +        final int index = ArrayIndex.getArrayIndex(key);
   4.237          if (isMapped(index)) {
   4.238              namedArgs = namedArgs.set(index, value, strict);
   4.239          } else {
   4.240 @@ -358,7 +357,7 @@
   4.241  
   4.242      @Override
   4.243      public void set(final int key, final long value, final boolean strict) {
   4.244 -        final int index = getArrayIndexNoThrow(key);
   4.245 +        final int index = ArrayIndex.getArrayIndex(key);
   4.246          if (isMapped(index)) {
   4.247              namedArgs = namedArgs.set(index, value, strict);
   4.248          } else {
   4.249 @@ -368,7 +367,7 @@
   4.250  
   4.251      @Override
   4.252      public void set(final int key, final double value, final boolean strict) {
   4.253 -        final int index = getArrayIndexNoThrow(key);
   4.254 +        final int index = ArrayIndex.getArrayIndex(key);
   4.255          if (isMapped(index)) {
   4.256              namedArgs = namedArgs.set(index, value, strict);
   4.257          } else {
   4.258 @@ -378,7 +377,7 @@
   4.259  
   4.260      @Override
   4.261      public void set(final int key, final Object value, final boolean strict) {
   4.262 -        final int index = getArrayIndexNoThrow(key);
   4.263 +        final int index = ArrayIndex.getArrayIndex(key);
   4.264          if (isMapped(index)) {
   4.265              namedArgs = namedArgs.set(index, value, strict);
   4.266          } else {
   4.267 @@ -388,55 +387,55 @@
   4.268  
   4.269      @Override
   4.270      public boolean has(final Object key) {
   4.271 -        final int index = getArrayIndexNoThrow(key);
   4.272 +        final int index = ArrayIndex.getArrayIndex(key);
   4.273          return isMapped(index) || super.has(key);
   4.274      }
   4.275  
   4.276      @Override
   4.277      public boolean has(final double key) {
   4.278 -        final int index = getArrayIndexNoThrow(key);
   4.279 +        final int index = ArrayIndex.getArrayIndex(key);
   4.280          return isMapped(index) || super.has(key);
   4.281      }
   4.282  
   4.283      @Override
   4.284      public boolean has(final long key) {
   4.285 -        final int index = getArrayIndexNoThrow(key);
   4.286 +        final int index = ArrayIndex.getArrayIndex(key);
   4.287          return isMapped(index) || super.has(key);
   4.288      }
   4.289  
   4.290      @Override
   4.291      public boolean has(final int key) {
   4.292 -        final int index = getArrayIndexNoThrow(key);
   4.293 +        final int index = ArrayIndex.getArrayIndex(key);
   4.294          return isMapped(index) || super.has(key);
   4.295      }
   4.296  
   4.297      @Override
   4.298      public boolean hasOwnProperty(final Object key) {
   4.299 -        final int index = getArrayIndexNoThrow(key);
   4.300 +        final int index = ArrayIndex.getArrayIndex(key);
   4.301          return isMapped(index) || super.hasOwnProperty(key);
   4.302      }
   4.303  
   4.304      @Override
   4.305      public boolean hasOwnProperty(final int key) {
   4.306 -        final int index = getArrayIndexNoThrow(key);
   4.307 +        final int index = ArrayIndex.getArrayIndex(key);
   4.308          return isMapped(index) || super.hasOwnProperty(key);
   4.309      }
   4.310  
   4.311      @Override
   4.312      public boolean hasOwnProperty(final long key) {
   4.313 -        final int index = getArrayIndexNoThrow(key);
   4.314 +        final int index = ArrayIndex.getArrayIndex(key);
   4.315          return isMapped(index) || super.hasOwnProperty(key);
   4.316      }
   4.317  
   4.318      @Override
   4.319      public boolean hasOwnProperty(final double key) {
   4.320 -        final int index = getArrayIndexNoThrow(key);
   4.321 +        final int index = ArrayIndex.getArrayIndex(key);
   4.322          return isMapped(index) || super.hasOwnProperty(key);
   4.323      }
   4.324  
   4.325      @Override
   4.326      public boolean delete(final int key, final boolean strict) {
   4.327 -        final int index = getArrayIndexNoThrow(key);
   4.328 +        final int index = ArrayIndex.getArrayIndex(key);
   4.329          final boolean success = super.delete(key, strict);
   4.330          if (success && namedArgs.has(index)) {
   4.331              setDeleted(index);
   4.332 @@ -446,7 +445,7 @@
   4.333  
   4.334      @Override
   4.335      public boolean delete(final long key, final boolean strict) {
   4.336 -        final int index = getArrayIndexNoThrow(key);
   4.337 +        final int index = ArrayIndex.getArrayIndex(key);
   4.338          final boolean success = super.delete(key, strict);
   4.339          if (success && namedArgs.has(index)) {
   4.340              setDeleted(index);
   4.341 @@ -456,7 +455,7 @@
   4.342  
   4.343      @Override
   4.344      public boolean delete(final double key, final boolean strict) {
   4.345 -        final int index = getArrayIndexNoThrow(key);
   4.346 +        final int index = ArrayIndex.getArrayIndex(key);
   4.347          final boolean success = super.delete(key, strict);
   4.348          if (success && namedArgs.has(index)) {
   4.349              setDeleted(index);
   4.350 @@ -466,7 +465,7 @@
   4.351  
   4.352      @Override
   4.353      public boolean delete(final Object key, final boolean strict) {
   4.354 -        final int index = getArrayIndexNoThrow(key);
   4.355 +        final int index = ArrayIndex.getArrayIndex(key);
   4.356          final boolean success = super.delete(key, strict);
   4.357          if (success && namedArgs.has(index)) {
   4.358              setDeleted(index);
   4.359 @@ -480,7 +479,7 @@
   4.360       */
   4.361      @Override
   4.362      public boolean defineOwnProperty(final String key, final Object propertyDesc, final boolean reject) {
   4.363 -        final int index = ArrayIndex.getArrayIndexNoThrow(key);
   4.364 +        final int index = ArrayIndex.getArrayIndex(key);
   4.365          if (index >= 0) {
   4.366              final boolean allowed = super.defineOwnProperty(key, propertyDesc, false);
   4.367              if (!allowed) {

     5.1 --- a/src/jdk/nashorn/internal/objects/NativeArray.java	Thu Jun 06 21:41:20 2013 +0530
     5.2 +++ b/src/jdk/nashorn/internal/objects/NativeArray.java	Fri Jun 07 17:44:25 2013 +0200
     5.3 @@ -228,7 +228,7 @@
     5.4          }
     5.5  
     5.6          // Step 4a
     5.7 -        final int index = ArrayIndex.getArrayIndexNoThrow(key);
     5.8 +        final int index = ArrayIndex.getArrayIndex(key);
     5.9          if (ArrayIndex.isValidArrayIndex(index)) {
    5.10              final long longIndex = ArrayIndex.toLongIndex(index);
    5.11              // Step 4b
    5.12 @@ -770,7 +770,7 @@
    5.13  
    5.14          final NativeArray copy = new NativeArray(0);
    5.15          for (long n = 0; k < finale; n++, k++) {
    5.16 -            copy.defineOwnProperty((int) n, sobj.get(k));
    5.17 +            copy.defineOwnProperty(ArrayIndex.getArrayIndex(n), sobj.get(k));
    5.18          }
    5.19  
    5.20          return copy;
    5.21 @@ -835,28 +835,26 @@
    5.22              final ScriptObject sobj    = (ScriptObject) self;
    5.23              final boolean      strict  = sobj.isStrictContext();
    5.24              final long         len     = JSType.toUint32(sobj.getLength());
    5.25 +            ArrayData          array   = sobj.getArray();
    5.26  
    5.27              if (len > 1) {
    5.28                  // Get only non-missing elements. Missing elements go at the end
    5.29                  // of the sorted array. So, just don't copy these to sort input.
    5.30 -
    5.31                  final ArrayList<Object> src = new ArrayList<>();
    5.32 -                for (int i = 0; i < (int)len; i++) {
    5.33 -                    if (sobj.has(i)) {
    5.34 -                        src.add(sobj.get(i));
    5.35 +                for (long i = 0; i < len; i = array.nextIndex(i)) {
    5.36 +                    if (array.has((int) i)) {
    5.37 +                        src.add(array.getObject((int) i));
    5.38                      }
    5.39                  }
    5.40  
    5.41                  final Object[] sorted = sort(src.toArray(), comparefn);
    5.42  
    5.43                  for (int i = 0; i < sorted.length; i++) {
    5.44 -                    sobj.set(i, sorted[i], strict);
    5.45 +                    array = array.set(i, sorted[i], strict);
    5.46                  }
    5.47  
    5.48                  // delete missing elements - which are at the end of sorted array
    5.49 -                for (int j = sorted.length; j < (int)len; j++) {
    5.50 -                    sobj.delete(j, strict);
    5.51 -                }
    5.52 +                sobj.setArray(array.delete(sorted.length, len - 1));
    5.53              }
    5.54  
    5.55              return sobj;
    5.56 @@ -906,7 +904,7 @@
    5.57              final long from = actualStart + k;
    5.58  
    5.59              if (sobj.has(from)) {
    5.60 -                array.defineOwnProperty((int) k, sobj.get(from));
    5.61 +                array.defineOwnProperty(ArrayIndex.getArrayIndex(k), sobj.get(from));
    5.62              }
    5.63          }
    5.64  
    5.65 @@ -1143,7 +1141,7 @@
    5.66              @Override
    5.67              protected boolean forEach(final Object val, final long i) throws Throwable {
    5.68                  final Object r = MAP_CALLBACK_INVOKER.invokeExact(callbackfn, thisArg, val, i, self);
    5.69 -                result.defineOwnProperty((int)index, r);
    5.70 +                result.defineOwnProperty(ArrayIndex.getArrayIndex(index), r);
    5.71                  return true;
    5.72              }
    5.73  
    5.74 @@ -1172,7 +1170,7 @@
    5.75              @Override
    5.76              protected boolean forEach(final Object val, final long i) throws Throwable {
    5.77                  if ((boolean)FILTER_CALLBACK_INVOKER.invokeExact(callbackfn, thisArg, val, i, self)) {
    5.78 -                    result.defineOwnProperty((int)(to++), val);
    5.79 +                    result.defineOwnProperty(ArrayIndex.getArrayIndex(to++), val);
    5.80                  }
    5.81                  return true;
    5.82              }

     6.1 --- a/src/jdk/nashorn/internal/objects/NativeString.java	Thu Jun 06 21:41:20 2013 +0530
     6.2 +++ b/src/jdk/nashorn/internal/objects/NativeString.java	Fri Jun 07 17:44:25 2013 +0200
     6.3 @@ -29,7 +29,6 @@
     6.4  import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
     6.5  import static jdk.nashorn.internal.runtime.JSType.isRepresentableAsInt;
     6.6  import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
     6.7 -import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.getArrayIndexNoThrow;
     6.8  
     6.9  import java.lang.invoke.MethodHandle;
    6.10  import java.lang.invoke.MethodHandles;
    6.11 @@ -156,7 +155,7 @@
    6.12      @SuppressWarnings("unused")
    6.13      private static Object get(final Object self, final Object key) {
    6.14          final CharSequence cs = JSType.toCharSequence(self);
    6.15 -        final int index = getArrayIndexNoThrow(key);
    6.16 +        final int index = ArrayIndex.getArrayIndex(key);
    6.17          if (index >= 0 && index < cs.length()) {
    6.18              return String.valueOf(cs.charAt(index));
    6.19          }
    6.20 @@ -191,7 +190,7 @@
    6.21      // String characters can be accessed with array-like indexing..
    6.22      @Override
    6.23      public Object get(final Object key) {
    6.24 -        final int index = getArrayIndexNoThrow(key);
    6.25 +        final int index = ArrayIndex.getArrayIndex(key);
    6.26          if (index >= 0 && index < value.length()) {
    6.27              return String.valueOf(value.charAt(index));
    6.28          }
    6.29 @@ -284,7 +283,7 @@
    6.30  
    6.31      @Override
    6.32      public boolean has(final Object key) {
    6.33 -        final int index = getArrayIndexNoThrow(key);
    6.34 +        final int index = ArrayIndex.getArrayIndex(key);
    6.35          return isValid(index) || super.has(key);
    6.36      }
    6.37  
    6.38 @@ -295,19 +294,19 @@
    6.39  
    6.40      @Override
    6.41      public boolean has(final long key) {
    6.42 -        final int index = getArrayIndexNoThrow(key);
    6.43 +        final int index = ArrayIndex.getArrayIndex(key);
    6.44          return isValid(index) || super.has(key);
    6.45      }
    6.46  
    6.47      @Override
    6.48      public boolean has(final double key) {
    6.49 -        final int index = getArrayIndexNoThrow(key);
    6.50 +        final int index = ArrayIndex.getArrayIndex(key);
    6.51          return isValid(index) || super.has(key);
    6.52      }
    6.53  
    6.54      @Override
    6.55      public boolean hasOwnProperty(final Object key) {
    6.56 -        final int index = getArrayIndexNoThrow(key);
    6.57 +        final int index = ArrayIndex.getArrayIndex(key);
    6.58          return isValid(index) || super.hasOwnProperty(key);
    6.59      }
    6.60  
    6.61 @@ -318,13 +317,13 @@
    6.62  
    6.63      @Override
    6.64      public boolean hasOwnProperty(final long key) {
    6.65 -        final int index = getArrayIndexNoThrow(key);
    6.66 +        final int index = ArrayIndex.getArrayIndex(key);
    6.67          return isValid(index) || super.hasOwnProperty(key);
    6.68      }
    6.69  
    6.70      @Override
    6.71      public boolean hasOwnProperty(final double key) {
    6.72 -        final int index = getArrayIndexNoThrow(key);
    6.73 +        final int index = ArrayIndex.getArrayIndex(key);
    6.74          return isValid(index) || super.hasOwnProperty(key);
    6.75      }
    6.76  
    6.77 @@ -335,19 +334,19 @@
    6.78  
    6.79      @Override
    6.80      public boolean delete(final long key, final boolean strict) {
    6.81 -        final int index = getArrayIndexNoThrow(key);
    6.82 +        final int index = ArrayIndex.getArrayIndex(key);
    6.83          return checkDeleteIndex(index, strict)? false : super.delete(key, strict);
    6.84      }
    6.85  
    6.86      @Override
    6.87      public boolean delete(final double key, final boolean strict) {
    6.88 -        final int index = getArrayIndexNoThrow(key);
    6.89 +        final int index = ArrayIndex.getArrayIndex(key);
    6.90          return checkDeleteIndex(index, strict)? false : super.delete(key, strict);
    6.91      }
    6.92  
    6.93      @Override
    6.94      public boolean delete(final Object key, final boolean strict) {
    6.95 -        final int index = getArrayIndexNoThrow(key);
    6.96 +        final int index = ArrayIndex.getArrayIndex(key);
    6.97          return checkDeleteIndex(index, strict)? false : super.delete(key, strict);
    6.98      }
    6.99  
   6.100 @@ -364,7 +363,7 @@
   6.101  
   6.102      @Override
   6.103      public Object getOwnPropertyDescriptor(final String key) {
   6.104 -        final int index = ArrayIndex.getArrayIndexNoThrow(key);
   6.105 +        final int index = ArrayIndex.getArrayIndex(key);
   6.106          if (index >= 0 && index < value.length()) {
   6.107              final Global global = Global.instance();
   6.108              return global.newDataDescriptor(String.valueOf(value.charAt(index)), false, true, false);

     7.1 --- a/src/jdk/nashorn/internal/runtime/JSONFunctions.java	Thu Jun 06 21:41:20 2013 +0530
     7.2 +++ b/src/jdk/nashorn/internal/runtime/JSONFunctions.java	Fri Jun 07 17:44:25 2013 +0200
     7.3 @@ -25,9 +25,6 @@
     7.4  
     7.5  package jdk.nashorn.internal.runtime;
     7.6  
     7.7 -import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.getArrayIndexNoThrow;
     7.8 -import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.isValidArrayIndex;
     7.9 -
    7.10  import java.lang.invoke.MethodHandle;
    7.11  import java.util.Iterator;
    7.12  import jdk.nashorn.internal.ir.LiteralNode;
    7.13 @@ -37,6 +34,7 @@
    7.14  import jdk.nashorn.internal.ir.UnaryNode;
    7.15  import jdk.nashorn.internal.parser.JSONParser;
    7.16  import jdk.nashorn.internal.parser.TokenType;
    7.17 +import jdk.nashorn.internal.runtime.arrays.ArrayIndex;
    7.18  import jdk.nashorn.internal.runtime.linker.Bootstrap;
    7.19  
    7.20  /**
    7.21 @@ -188,8 +186,8 @@
    7.22  
    7.23      // add a new property if does not exist already, or else set old property
    7.24      private static void setPropertyValue(final ScriptObject sobj, final String name, final Object value, final boolean strict) {
    7.25 -        final int index = getArrayIndexNoThrow(name);
    7.26 -        if (isValidArrayIndex(index)) {
    7.27 +        final int index = ArrayIndex.getArrayIndex(name);
    7.28 +        if (ArrayIndex.isValidArrayIndex(index)) {
    7.29              // array index key
    7.30              sobj.defineOwnProperty(index, value);
    7.31          } else if (sobj.getMap().findProperty(name) != null) {

     8.1 --- a/src/jdk/nashorn/internal/runtime/ScriptObject.java	Thu Jun 06 21:41:20 2013 +0530
     8.2 +++ b/src/jdk/nashorn/internal/runtime/ScriptObject.java	Fri Jun 07 17:44:25 2013 +0200
     8.3 @@ -37,8 +37,6 @@
     8.4  import static jdk.nashorn.internal.runtime.PropertyDescriptor.VALUE;
     8.5  import static jdk.nashorn.internal.runtime.PropertyDescriptor.WRITABLE;
     8.6  import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
     8.7 -import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.getArrayIndexNoThrow;
     8.8 -import static jdk.nashorn.internal.runtime.arrays.ArrayIndex.isValidArrayIndex;
     8.9  
    8.10  import java.lang.invoke.MethodHandle;
    8.11  import java.lang.invoke.MethodHandles;
    8.12 @@ -65,6 +63,7 @@
    8.13  import jdk.nashorn.internal.objects.AccessorPropertyDescriptor;
    8.14  import jdk.nashorn.internal.objects.DataPropertyDescriptor;
    8.15  import jdk.nashorn.internal.runtime.arrays.ArrayData;
    8.16 +import jdk.nashorn.internal.runtime.arrays.ArrayIndex;
    8.17  import jdk.nashorn.internal.runtime.linker.Bootstrap;
    8.18  import jdk.nashorn.internal.runtime.linker.LinkerCallSite;
    8.19  import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
    8.20 @@ -333,7 +332,7 @@
    8.21              return global.newDataDescriptor(getWithProperty(property), configurable, enumerable, writable);
    8.22          }
    8.23  
    8.24 -        final int index = getArrayIndexNoThrow(key);
    8.25 +        final int index = ArrayIndex.getArrayIndex(key);
    8.26          final ArrayData array = getArray();
    8.27  
    8.28          if (array.has(index)) {
    8.29 @@ -533,21 +532,23 @@
    8.30       * from any object in proto chain such as Array.prototype, Object.prototype.
    8.31       * This method directly sets a particular element value in the current object.
    8.32       *
    8.33 -     * @param index index key for property
    8.34 +     * @param index key for property
    8.35       * @param value value to define
    8.36       */
    8.37      protected final void defineOwnProperty(final int index, final Object value) {
    8.38 -        if (index >= getArray().length()) {
    8.39 +        assert ArrayIndex.isValidArrayIndex(index) : "invalid array index";
    8.40 +        final long longIndex = ArrayIndex.toLongIndex(index);
    8.41 +        if (longIndex >= getArray().length()) {
    8.42              // make array big enough to hold..
    8.43 -            setArray(getArray().ensure(index));
    8.44 +            setArray(getArray().ensure(longIndex));
    8.45          }
    8.46          setArray(getArray().set(index, value, false));
    8.47      }
    8.48  
    8.49      private void checkIntegerKey(final String key) {
    8.50 -        final int index = getArrayIndexNoThrow(key);
    8.51 -
    8.52 -        if (isValidArrayIndex(index)) {
    8.53 +        final int index = ArrayIndex.getArrayIndex(key);
    8.54 +
    8.55 +        if (ArrayIndex.isValidArrayIndex(index)) {
    8.56              final ArrayData data = getArray();
    8.57  
    8.58              if (data.has(index)) {
    8.59 @@ -557,7 +558,7 @@
    8.60      }
    8.61  
    8.62      private void removeArraySlot(final String key) {
    8.63 -        final int index = getArrayIndexNoThrow(key);
    8.64 +        final int index = ArrayIndex.getArrayIndex(key);
    8.65          final ArrayData array = getArray();
    8.66  
    8.67          if (array.has(index)) {
    8.68 @@ -2238,7 +2239,7 @@
    8.69      }
    8.70  
    8.71      private int getInt(final int index, final String key) {
    8.72 -        if (isValidArrayIndex(index)) {
    8.73 +        if (ArrayIndex.isValidArrayIndex(index)) {
    8.74               for (ScriptObject object = this; ; ) {
    8.75                  final FindProperty find = object.findProperty(key, false, false, this);
    8.76  
    8.77 @@ -2269,7 +2270,7 @@
    8.78  
    8.79      @Override
    8.80      public int getInt(final Object key) {
    8.81 -        final int index = getArrayIndexNoThrow(key);
    8.82 +        final int index = ArrayIndex.getArrayIndex(key);
    8.83          final ArrayData array = getArray();
    8.84  
    8.85          if (array.has(index)) {
    8.86 @@ -2281,7 +2282,7 @@
    8.87  
    8.88      @Override
    8.89      public int getInt(final double key) {
    8.90 -        final int index = getArrayIndexNoThrow(key);
    8.91 +        final int index = ArrayIndex.getArrayIndex(key);
    8.92          final ArrayData array = getArray();
    8.93  
    8.94          if (array.has(index)) {
    8.95 @@ -2293,7 +2294,7 @@
    8.96  
    8.97      @Override
    8.98      public int getInt(final long key) {
    8.99 -        final int index = getArrayIndexNoThrow(key);
   8.100 +        final int index = ArrayIndex.getArrayIndex(key);
   8.101          final ArrayData array = getArray();
   8.102  
   8.103          if (array.has(index)) {
   8.104 @@ -2315,7 +2316,7 @@
   8.105      }
   8.106  
   8.107      private long getLong(final int index, final String key) {
   8.108 -        if (isValidArrayIndex(index)) {
   8.109 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.110              for (ScriptObject object = this; ; ) {
   8.111                  final FindProperty find = object.findProperty(key, false, false, this);
   8.112  
   8.113 @@ -2346,7 +2347,7 @@
   8.114  
   8.115      @Override
   8.116      public long getLong(final Object key) {
   8.117 -        final int index = getArrayIndexNoThrow(key);
   8.118 +        final int index = ArrayIndex.getArrayIndex(key);
   8.119          final ArrayData array = getArray();
   8.120  
   8.121          if (array.has(index)) {
   8.122 @@ -2358,7 +2359,7 @@
   8.123  
   8.124      @Override
   8.125      public long getLong(final double key) {
   8.126 -        final int index = getArrayIndexNoThrow(key);
   8.127 +        final int index = ArrayIndex.getArrayIndex(key);
   8.128          final ArrayData array = getArray();
   8.129  
   8.130          if (array.has(index)) {
   8.131 @@ -2370,7 +2371,7 @@
   8.132  
   8.133      @Override
   8.134      public long getLong(final long key) {
   8.135 -        final int index = getArrayIndexNoThrow(key);
   8.136 +        final int index = ArrayIndex.getArrayIndex(key);
   8.137          final ArrayData array = getArray();
   8.138  
   8.139          if (array.has(index)) {
   8.140 @@ -2392,7 +2393,7 @@
   8.141      }
   8.142  
   8.143      private double getDouble(final int index, final String key) {
   8.144 -        if (isValidArrayIndex(index)) {
   8.145 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.146              for (ScriptObject object = this; ; ) {
   8.147                  final FindProperty find = object.findProperty(key, false, false, this);
   8.148  
   8.149 @@ -2423,7 +2424,7 @@
   8.150  
   8.151      @Override
   8.152      public double getDouble(final Object key) {
   8.153 -        final int index = getArrayIndexNoThrow(key);
   8.154 +        final int index = ArrayIndex.getArrayIndex(key);
   8.155          final ArrayData array = getArray();
   8.156  
   8.157          if (array.has(index)) {
   8.158 @@ -2435,7 +2436,7 @@
   8.159  
   8.160      @Override
   8.161      public double getDouble(final double key) {
   8.162 -        final int index = getArrayIndexNoThrow(key);
   8.163 +        final int index = ArrayIndex.getArrayIndex(key);
   8.164          final ArrayData array = getArray();
   8.165  
   8.166          if (array.has(index)) {
   8.167 @@ -2447,7 +2448,7 @@
   8.168  
   8.169      @Override
   8.170      public double getDouble(final long key) {
   8.171 -        final int index = getArrayIndexNoThrow(key);
   8.172 +        final int index = ArrayIndex.getArrayIndex(key);
   8.173          final ArrayData array = getArray();
   8.174  
   8.175          if (array.has(index)) {
   8.176 @@ -2469,7 +2470,7 @@
   8.177      }
   8.178  
   8.179      private Object get(final int index, final String key) {
   8.180 -        if (isValidArrayIndex(index)) {
   8.181 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.182              for (ScriptObject object = this; ; ) {
   8.183                  final FindProperty find = object.findProperty(key, false, false, this);
   8.184  
   8.185 @@ -2500,7 +2501,7 @@
   8.186  
   8.187      @Override
   8.188      public Object get(final Object key) {
   8.189 -        final int index = getArrayIndexNoThrow(key);
   8.190 +        final int index = ArrayIndex.getArrayIndex(key);
   8.191          final ArrayData array = getArray();
   8.192  
   8.193          if (array.has(index)) {
   8.194 @@ -2512,7 +2513,7 @@
   8.195  
   8.196      @Override
   8.197      public Object get(final double key) {
   8.198 -        final int index = getArrayIndexNoThrow(key);
   8.199 +        final int index = ArrayIndex.getArrayIndex(key);
   8.200          final ArrayData array = getArray();
   8.201  
   8.202          if (array.has(index)) {
   8.203 @@ -2524,7 +2525,7 @@
   8.204  
   8.205      @Override
   8.206      public Object get(final long key) {
   8.207 -        final int index = getArrayIndexNoThrow(key);
   8.208 +        final int index = ArrayIndex.getArrayIndex(key);
   8.209          final ArrayData array = getArray();
   8.210  
   8.211          if (array.has(index)) {
   8.212 @@ -2640,9 +2641,9 @@
   8.213  
   8.214      @Override
   8.215      public void set(final Object key, final int value, final boolean strict) {
   8.216 -        final int index = getArrayIndexNoThrow(key);
   8.217 -
   8.218 -        if (isValidArrayIndex(index)) {
   8.219 +        final int index = ArrayIndex.getArrayIndex(key);
   8.220 +
   8.221 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.222              if (getArray().has(index)) {
   8.223                  setArray(getArray().set(index, value, strict));
   8.224              } else {
   8.225 @@ -2657,9 +2658,9 @@
   8.226  
   8.227      @Override
   8.228      public void set(final Object key, final long value, final boolean strict) {
   8.229 -        final int index = getArrayIndexNoThrow(key);
   8.230 -
   8.231 -        if (isValidArrayIndex(index)) {
   8.232 +        final int index = ArrayIndex.getArrayIndex(key);
   8.233 +
   8.234 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.235              if (getArray().has(index)) {
   8.236                  setArray(getArray().set(index, value, strict));
   8.237              } else {
   8.238 @@ -2674,9 +2675,9 @@
   8.239  
   8.240      @Override
   8.241      public void set(final Object key, final double value, final boolean strict) {
   8.242 -        final int index = getArrayIndexNoThrow(key);
   8.243 -
   8.244 -        if (isValidArrayIndex(index)) {
   8.245 +        final int index = ArrayIndex.getArrayIndex(key);
   8.246 +
   8.247 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.248              if (getArray().has(index)) {
   8.249                  setArray(getArray().set(index, value, strict));
   8.250              } else {
   8.251 @@ -2691,9 +2692,9 @@
   8.252  
   8.253      @Override
   8.254      public void set(final Object key, final Object value, final boolean strict) {
   8.255 -        final int index = getArrayIndexNoThrow(key);
   8.256 -
   8.257 -        if (isValidArrayIndex(index)) {
   8.258 +        final int index = ArrayIndex.getArrayIndex(key);
   8.259 +
   8.260 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.261              if (getArray().has(index)) {
   8.262                  setArray(getArray().set(index, value, strict));
   8.263              } else {
   8.264 @@ -2711,9 +2712,9 @@
   8.265  
   8.266      @Override
   8.267      public void set(final double key, final int value, final boolean strict) {
   8.268 -        final int index = getArrayIndexNoThrow(key);
   8.269 -
   8.270 -        if (isValidArrayIndex(index)) {
   8.271 +        final int index = ArrayIndex.getArrayIndex(key);
   8.272 +
   8.273 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.274              if (getArray().has(index)) {
   8.275                  setArray(getArray().set(index, value, strict));
   8.276              } else {
   8.277 @@ -2728,9 +2729,9 @@
   8.278  
   8.279      @Override
   8.280      public void set(final double key, final long value, final boolean strict) {
   8.281 -        final int index = getArrayIndexNoThrow(key);
   8.282 -
   8.283 -        if (isValidArrayIndex(index)) {
   8.284 +        final int index = ArrayIndex.getArrayIndex(key);
   8.285 +
   8.286 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.287              if (getArray().has(index)) {
   8.288                  setArray(getArray().set(index, value, strict));
   8.289              } else {
   8.290 @@ -2745,9 +2746,9 @@
   8.291  
   8.292      @Override
   8.293      public void set(final double key, final double value, final boolean strict) {
   8.294 -        final int index = getArrayIndexNoThrow(key);
   8.295 -
   8.296 -        if (isValidArrayIndex(index)) {
   8.297 +        final int index = ArrayIndex.getArrayIndex(key);
   8.298 +
   8.299 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.300              if (getArray().has(index)) {
   8.301                  setArray(getArray().set(index, value, strict));
   8.302              } else {
   8.303 @@ -2762,9 +2763,9 @@
   8.304  
   8.305      @Override
   8.306      public void set(final double key, final Object value, final boolean strict) {
   8.307 -        final int index = getArrayIndexNoThrow(key);
   8.308 -
   8.309 -        if (isValidArrayIndex(index)) {
   8.310 +        final int index = ArrayIndex.getArrayIndex(key);
   8.311 +
   8.312 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.313              if (getArray().has(index)) {
   8.314                  setArray(getArray().set(index, value, strict));
   8.315              } else {
   8.316 @@ -2779,9 +2780,9 @@
   8.317  
   8.318      @Override
   8.319      public void set(final long key, final int value, final boolean strict) {
   8.320 -        final int index = getArrayIndexNoThrow(key);
   8.321 -
   8.322 -        if (isValidArrayIndex(index)) {
   8.323 +        final int index = ArrayIndex.getArrayIndex(key);
   8.324 +
   8.325 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.326              if (getArray().has(index)) {
   8.327                  setArray(getArray().set(index, value, strict));
   8.328              } else {
   8.329 @@ -2796,9 +2797,9 @@
   8.330  
   8.331      @Override
   8.332      public void set(final long key, final long value, final boolean strict) {
   8.333 -        final int index = getArrayIndexNoThrow(key);
   8.334 -
   8.335 -        if (isValidArrayIndex(index)) {
   8.336 +        final int index = ArrayIndex.getArrayIndex(key);
   8.337 +
   8.338 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.339              if (getArray().has(index)) {
   8.340                  setArray(getArray().set(index, value, strict));
   8.341              } else {
   8.342 @@ -2813,9 +2814,9 @@
   8.343  
   8.344      @Override
   8.345      public void set(final long key, final double value, final boolean strict) {
   8.346 -        final int index = getArrayIndexNoThrow(key);
   8.347 -
   8.348 -        if (isValidArrayIndex(index)) {
   8.349 +        final int index = ArrayIndex.getArrayIndex(key);
   8.350 +
   8.351 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.352              if (getArray().has(index)) {
   8.353                  setArray(getArray().set(index, value, strict));
   8.354              } else {
   8.355 @@ -2830,9 +2831,9 @@
   8.356  
   8.357      @Override
   8.358      public void set(final long key, final Object value, final boolean strict) {
   8.359 -        final int index = getArrayIndexNoThrow(key);
   8.360 -
   8.361 -        if (isValidArrayIndex(index)) {
   8.362 +        final int index = ArrayIndex.getArrayIndex(key);
   8.363 +
   8.364 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.365              if (getArray().has(index)) {
   8.366                  setArray(getArray().set(index, value, strict));
   8.367              } else {
   8.368 @@ -2847,9 +2848,9 @@
   8.369  
   8.370      @Override
   8.371      public void set(final int key, final int value, final boolean strict) {
   8.372 -        final int index = getArrayIndexNoThrow(key);
   8.373 -
   8.374 -        if (isValidArrayIndex(index)) {
   8.375 +        final int index = ArrayIndex.getArrayIndex(key);
   8.376 +
   8.377 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.378              if (getArray().has(index)) {
   8.379                  setArray(getArray().set(index, value, strict));
   8.380              } else {
   8.381 @@ -2864,9 +2865,9 @@
   8.382  
   8.383      @Override
   8.384      public void set(final int key, final long value, final boolean strict) {
   8.385 -        final int index = getArrayIndexNoThrow(key);
   8.386 -
   8.387 -        if (isValidArrayIndex(index)) {
   8.388 +        final int index = ArrayIndex.getArrayIndex(key);
   8.389 +
   8.390 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.391              if (getArray().has(index)) {
   8.392                  setArray(getArray().set(index, value, strict));
   8.393              } else {
   8.394 @@ -2881,9 +2882,9 @@
   8.395  
   8.396      @Override
   8.397      public void set(final int key, final double value, final boolean strict) {
   8.398 -        final int index = getArrayIndexNoThrow(key);
   8.399 -
   8.400 -        if (isValidArrayIndex(index)) {
   8.401 +        final int index = ArrayIndex.getArrayIndex(key);
   8.402 +
   8.403 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.404              if (getArray().has(index)) {
   8.405                  setArray(getArray().set(index, value, strict));
   8.406              } else {
   8.407 @@ -2898,9 +2899,9 @@
   8.408  
   8.409      @Override
   8.410      public void set(final int key, final Object value, final boolean strict) {
   8.411 -        final int index = getArrayIndexNoThrow(key);
   8.412 -
   8.413 -        if (isValidArrayIndex(index)) {
   8.414 +        final int index = ArrayIndex.getArrayIndex(key);
   8.415 +
   8.416 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.417              if (getArray().has(index)) {
   8.418                  setArray(getArray().set(index, value, strict));
   8.419              } else {
   8.420 @@ -2915,9 +2916,9 @@
   8.421  
   8.422      @Override
   8.423      public boolean has(final Object key) {
   8.424 -        final int index = getArrayIndexNoThrow(key);
   8.425 -
   8.426 -        if (isValidArrayIndex(index)) {
   8.427 +        final int index = ArrayIndex.getArrayIndex(key);
   8.428 +
   8.429 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.430              for (ScriptObject self = this; self != null; self = self.getProto()) {
   8.431                  if (self.getArray().has(index)) {
   8.432                      return true;
   8.433 @@ -2932,9 +2933,9 @@
   8.434  
   8.435      @Override
   8.436      public boolean has(final double key) {
   8.437 -        final int index = getArrayIndexNoThrow(key);
   8.438 -
   8.439 -        if (isValidArrayIndex(index)) {
   8.440 +        final int index = ArrayIndex.getArrayIndex(key);
   8.441 +
   8.442 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.443              for (ScriptObject self = this; self != null; self = self.getProto()) {
   8.444                  if (self.getArray().has(index)) {
   8.445                      return true;
   8.446 @@ -2949,9 +2950,9 @@
   8.447  
   8.448      @Override
   8.449      public boolean has(final long key) {
   8.450 -        final int index = getArrayIndexNoThrow(key);
   8.451 -
   8.452 -        if (isValidArrayIndex(index)) {
   8.453 +        final int index = ArrayIndex.getArrayIndex(key);
   8.454 +
   8.455 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.456              for (ScriptObject self = this; self != null; self = self.getProto()) {
   8.457                  if (self.getArray().has(index)) {
   8.458                      return true;
   8.459 @@ -2966,9 +2967,9 @@
   8.460  
   8.461      @Override
   8.462      public boolean has(final int key) {
   8.463 -        final int index = getArrayIndexNoThrow(key);
   8.464 -
   8.465 -        if (isValidArrayIndex(index)) {
   8.466 +        final int index = ArrayIndex.getArrayIndex(key);
   8.467 +
   8.468 +        if (ArrayIndex.isValidArrayIndex(index)) {
   8.469              for (ScriptObject self = this; self != null; self = self.getProto()) {
   8.470                  if (self.getArray().has(index)) {
   8.471                      return true;
   8.472 @@ -2983,7 +2984,7 @@
   8.473  
   8.474      @Override
   8.475      public boolean hasOwnProperty(final Object key) {
   8.476 -        final int index = getArrayIndexNoThrow(key);
   8.477 +        final int index = ArrayIndex.getArrayIndex(key);
   8.478  
   8.479          if (getArray().has(index)) {
   8.480              return true;
   8.481 @@ -2996,7 +2997,7 @@
   8.482  
   8.483      @Override
   8.484      public boolean hasOwnProperty(final int key) {
   8.485 -        final int index = getArrayIndexNoThrow(key);
   8.486 +        final int index = ArrayIndex.getArrayIndex(key);
   8.487  
   8.488          if (getArray().has(index)) {
   8.489              return true;
   8.490 @@ -3009,7 +3010,7 @@
   8.491  
   8.492      @Override
   8.493      public boolean hasOwnProperty(final long key) {
   8.494 -        final int index = getArrayIndexNoThrow(key);
   8.495 +        final int index = ArrayIndex.getArrayIndex(key);
   8.496  
   8.497          if (getArray().has(index)) {
   8.498              return true;
   8.499 @@ -3022,7 +3023,7 @@
   8.500  
   8.501      @Override
   8.502      public boolean hasOwnProperty(final double key) {
   8.503 -        final int index = getArrayIndexNoThrow(key);
   8.504 +        final int index = ArrayIndex.getArrayIndex(key);
   8.505  
   8.506          if (getArray().has(index)) {
   8.507              return true;
   8.508 @@ -3035,7 +3036,7 @@
   8.509  
   8.510      @Override
   8.511      public boolean delete(final int key, final boolean strict) {
   8.512 -        final int index = getArrayIndexNoThrow(key);
   8.513 +        final int index = ArrayIndex.getArrayIndex(key);
   8.514          final ArrayData array = getArray();
   8.515  
   8.516          if (array.has(index)) {
   8.517 @@ -3051,7 +3052,7 @@
   8.518  
   8.519      @Override
   8.520      public boolean delete(final long key, final boolean strict) {
   8.521 -        final int index = getArrayIndexNoThrow(key);
   8.522 +        final int index = ArrayIndex.getArrayIndex(key);
   8.523          final ArrayData array = getArray();
   8.524  
   8.525          if (array.has(index)) {
   8.526 @@ -3067,7 +3068,7 @@
   8.527  
   8.528      @Override
   8.529      public boolean delete(final double key, final boolean strict) {
   8.530 -        final int index = getArrayIndexNoThrow(key);
   8.531 +        final int index = ArrayIndex.getArrayIndex(key);
   8.532          final ArrayData array = getArray();
   8.533  
   8.534          if (array.has(index)) {
   8.535 @@ -3083,7 +3084,7 @@
   8.536  
   8.537      @Override
   8.538      public boolean delete(final Object key, final boolean strict) {
   8.539 -        final int index = getArrayIndexNoThrow(key);
   8.540 +        final int index = ArrayIndex.getArrayIndex(key);
   8.541          final ArrayData array = getArray();
   8.542  
   8.543          if (array.has(index)) {

     9.1 --- a/src/jdk/nashorn/internal/runtime/arrays/ArrayIndex.java	Thu Jun 06 21:41:20 2013 +0530
     9.2 +++ b/src/jdk/nashorn/internal/runtime/arrays/ArrayIndex.java	Fri Jun 07 17:44:25 2013 +0200
     9.3 @@ -44,7 +44,7 @@
     9.4      /**
     9.5       * Fast conversion of non-negative integer string to long.
     9.6       * @param key Key as a string.
     9.7 -     * @return long value of string or -1.
     9.8 +     * @return long value of string or {@code -1} if string does not represent a valid index.
     9.9       */
    9.10      private static long fromString(final String key) {
    9.11          long value = 0;
    9.12 @@ -52,7 +52,7 @@
    9.13  
    9.14          // Check for empty string or leading 0
    9.15          if (length == 0 || (length > 1 && key.charAt(0) == '0')) {
    9.16 -            return -1;
    9.17 +            return INVALID_ARRAY_INDEX;
    9.18          }
    9.19  
    9.20          // Fast toNumber.
    9.21 @@ -61,7 +61,7 @@
    9.22  
    9.23              // If not a digit.
    9.24              if (digit < '0' || digit > '9') {
    9.25 -                return -1;
    9.26 +                return INVALID_ARRAY_INDEX;
    9.27              }
    9.28  
    9.29              // Insert digit.
    9.30 @@ -69,7 +69,7 @@
    9.31  
    9.32              // Check for overflow (need to catch before wrap around.)
    9.33              if (value > MAX_ARRAY_INDEX) {
    9.34 -                return -1;
    9.35 +                return INVALID_ARRAY_INDEX;
    9.36              }
    9.37          }
    9.38  
    9.39 @@ -81,137 +81,79 @@
    9.40       * routine needs to perform quickly since all keys are tested with it.
    9.41       *
    9.42       * @param  key key to check for array index
    9.43 -     * @return valid array index, or negative value if not valid
    9.44 +     * @return the array index, or {@code -1} if {@code key} does not represent a valid index.
    9.45 +     *         Note that negative return values other than {@code -1} are considered valid and can be converted to
    9.46 +     *         the actual index using {@link #toLongIndex(int)}.
    9.47       */
    9.48 -    public static int getArrayIndexNoThrow(final Object key) {
    9.49 +    public static int getArrayIndex(final Object key) {
    9.50          if (key instanceof Integer) {
    9.51 -            return getArrayIndexNoThrow(((Integer)key).intValue());
    9.52 +            return getArrayIndex(((Integer) key).intValue());
    9.53          } else if (key instanceof Number) {
    9.54 -            return getArrayIndexNoThrow(((Number)key).doubleValue());
    9.55 +            return getArrayIndex(((Number) key).doubleValue());
    9.56          } else if (key instanceof String) {
    9.57 -            return (int)fromString((String)key);
    9.58 +            return (int)fromString((String) key);
    9.59          } else if (key instanceof ConsString) {
    9.60              return (int)fromString(key.toString());
    9.61          }
    9.62  
    9.63 -        return -1;
    9.64 +        return INVALID_ARRAY_INDEX;
    9.65      }
    9.66  
    9.67      /**
    9.68 -     * Returns a valid array index in an int, if the object represents one
    9.69 +     * Returns a valid array index in an int, if the long represents one.
    9.70       *
    9.71       * @param key key to check
    9.72 -     * @return array index for key
    9.73 -     * @throws InvalidArrayIndexException if not a valid array index key
    9.74 +     * @return the array index, or {@code -1} if long is not a valid array index.
    9.75 +     *         Note that negative return values other than {@code -1} are considered valid and can be converted to
    9.76 +     *         the actual index using {@link #toLongIndex(int)}.
    9.77       */
    9.78 -    public static int getArrayIndex(final Object key) throws InvalidArrayIndexException {
    9.79 -        final int index = getArrayIndexNoThrow(key);
    9.80 -        if (index != -1) {
    9.81 -            return index;
    9.82 -        }
    9.83 -
    9.84 -        throw new InvalidArrayIndexException(key);
    9.85 -    }
    9.86 -
    9.87 -    /**
    9.88 -     * Returns a valid array index in an int, if the long represents one
    9.89 -     *
    9.90 -     * @param key key to check
    9.91 -     * @return valid index or a negative value if long is not a valid array index
    9.92 -     */
    9.93 -    public static int getArrayIndexNoThrow(final long key) {
    9.94 +    public static int getArrayIndex(final long key) {
    9.95          if (key >= 0 && key <= MAX_ARRAY_INDEX) {
    9.96              return (int)key;
    9.97          }
    9.98  
    9.99 -        return -1;
   9.100 +        return INVALID_ARRAY_INDEX;
   9.101      }
   9.102  
   9.103 -    /**
   9.104 -     * Returns a valid array index in an int, if the long represents one
   9.105 -     *
   9.106 -     * @param key key to check
   9.107 -     * @return valid index for the long
   9.108 -     * @throws InvalidArrayIndexException if long is not a valid array index
   9.109 -     */
   9.110 -    public static int getArrayIndex(final long key) throws InvalidArrayIndexException {
   9.111 -        final int index = getArrayIndexNoThrow(key);
   9.112 -        if (index != -1) {
   9.113 -            return index;
   9.114 -        }
   9.115 -
   9.116 -        throw new InvalidArrayIndexException(key);
   9.117 -    }
   9.118 -
   9.119  
   9.120      /**
   9.121 -     * Return a valid index for this double, if it represents one
   9.122 +     * Return a valid index for this double, if it represents one.
   9.123       *
   9.124       * Doubles that aren't representable exactly as longs/ints aren't working
   9.125       * array indexes, however, array[1.1] === array["1.1"] in JavaScript.
   9.126       *
   9.127       * @param key the key to check
   9.128 -     * @return the array index this double represents or a negative value if this isn't an index
   9.129 +     * @return the array index this double represents or {@code -1} if this isn't a valid index.
   9.130 +     *         Note that negative return values other than {@code -1} are considered valid and can be converted to
   9.131 +     *         the actual index using {@link #toLongIndex(int)}.
   9.132       */
   9.133 -    public static int getArrayIndexNoThrow(final double key) {
   9.134 +    public static int getArrayIndex(final double key) {
   9.135          if (JSType.isRepresentableAsInt(key)) {
   9.136              final int intKey = (int)key;
   9.137              if (intKey >= 0) {
   9.138                  return intKey;
   9.139              }
   9.140          } else if (JSType.isRepresentableAsLong(key)) {
   9.141 -            return getArrayIndexNoThrow((long)key);
   9.142 +            return getArrayIndex((long) key);
   9.143          }
   9.144  
   9.145 -        return -1;
   9.146 +        return INVALID_ARRAY_INDEX;
   9.147      }
   9.148  
   9.149 +
   9.150      /**
   9.151 -     * Return a valid array index for this double, if it represents one
   9.152 -     *
   9.153 -     * Doubles that aren't representable exactly as longs/ints aren't working
   9.154 -     * array indexes, however, array[1.1] === array["1.1"] in JavaScript.
   9.155 +     * Return a valid array index for this string, if it represents one.
   9.156       *
   9.157       * @param key the key to check
   9.158 -     * @return the array index this double represents
   9.159 -     * @throws InvalidArrayIndexException if this isn't an array index
   9.160 +     * @return the array index this string represents or {@code -1} if this isn't a valid index.
   9.161 +     *         Note that negative return values other than {@code -1} are considered valid and can be converted to
   9.162 +     *         the actual index using {@link #toLongIndex(int)}.
   9.163       */
   9.164 -    public static int getArrayIndex(final double key) throws InvalidArrayIndexException {
   9.165 -        final int index = getArrayIndexNoThrow(key);
   9.166 -        if (index != -1) {
   9.167 -            return index;
   9.168 -        }
   9.169 -
   9.170 -        throw new InvalidArrayIndexException(key);
   9.171 -    }
   9.172 -
   9.173 -    /**
   9.174 -     * Return a valid array index for this string, if it represents one
   9.175 -     *
   9.176 -     * @param key the key to check
   9.177 -     * @return the array index this string represents or a negative value if this isn't an index
   9.178 -     */
   9.179 -    public static int getArrayIndexNoThrow(final String key) {
   9.180 +    public static int getArrayIndex(final String key) {
   9.181          return (int)fromString(key);
   9.182      }
   9.183  
   9.184      /**
   9.185 -     * Return a valid array index for this string, if it represents one
   9.186 -     *
   9.187 -     * @param key the key to check
   9.188 -     * @return the array index this string represents
   9.189 -     * @throws InvalidArrayIndexException if the string isn't an array index
   9.190 -     */
   9.191 -    public static int getArrayIndex(final String key) throws InvalidArrayIndexException {
   9.192 -        final int index = getArrayIndexNoThrow(key);
   9.193 -        if (index != -1) {
   9.194 -            return index;
   9.195 -        }
   9.196 -
   9.197 -        throw new InvalidArrayIndexException(key);
   9.198 -    }
   9.199 -
   9.200 -    /**
   9.201       * Check whether an index is valid as an array index. This check only tests if
   9.202       * it is the special "invalid array index" type, not if it is e.g. less than zero
   9.203       * or corrupt in some other way
   9.204 @@ -226,7 +168,7 @@
   9.205      /**
   9.206       * Convert an index to a long value. This basically amounts to ANDing it
   9.207       * with {@link JSType#MAX_UINT}, as the maximum array index in JavaScript
   9.208 -     * is 0xffffffff
   9.209 +     * is 0xfffffffe
   9.210       *
   9.211       * @param index index to convert to long form
   9.212       * @return index as uint32 in a long
   9.213 @@ -236,14 +178,14 @@
   9.214      }
   9.215  
   9.216      /**
   9.217 -     * Check whether a key string can be used as a valid numeric array index in
   9.218 -     * JavaScript
   9.219 +     * Check whether a key string represents a valid array index in JavaScript and is small enough
   9.220 +     * to fit into a positive int.
   9.221       *
   9.222       * @param key the key
   9.223 -     * @return true if key works as a valid numeric array index
   9.224 +     * @return true if key works as a valid int array index
   9.225       */
   9.226 -    public static boolean isIndexKey(final String key) {
   9.227 -       return ArrayIndex.getArrayIndexNoThrow(key) >= 0;
   9.228 +    public static boolean isIntArrayIndex(final String key) {
   9.229 +        return getArrayIndex(key) >= 0;
   9.230      }
   9.231  }
   9.232  

    10.1 --- a/src/jdk/nashorn/internal/runtime/arrays/SparseArrayData.java	Thu Jun 06 21:41:20 2013 +0530
    10.2 +++ b/src/jdk/nashorn/internal/runtime/arrays/SparseArrayData.java	Fri Jun 07 17:44:25 2013 +0200
    10.3 @@ -61,13 +61,15 @@
    10.4  
    10.5      @Override
    10.6      public Object[] asObjectArray() {
    10.7 -        final Object[] objArray = new Object[Math.min((int) length(), Integer.MAX_VALUE)];
    10.8 +        final int length = (int) Math.min(length(), Integer.MAX_VALUE);
    10.9 +        final int underlyingLength = (int) Math.min(length, underlying.length());
   10.10 +        final Object[] objArray = new Object[length];
   10.11  
   10.12 -        for (int i = 0; i < underlying.length(); i++) {
   10.13 +        for (int i = 0; i < underlyingLength; i++) {
   10.14              objArray[i] = underlying.getObject(i);
   10.15          }
   10.16  
   10.17 -        Arrays.fill(objArray, (int) underlying.length(), objArray.length, ScriptRuntime.UNDEFINED);
   10.18 +        Arrays.fill(objArray, underlyingLength, length, ScriptRuntime.UNDEFINED);
   10.19  
   10.20          for (final Map.Entry<Long, Object> entry : sparseMap.entrySet()) {
   10.21              final long key = entry.getKey();

    11.1 --- a/src/jdk/nashorn/internal/runtime/resources/Messages.properties	Thu Jun 06 21:41:20 2013 +0530
    11.2 +++ b/src/jdk/nashorn/internal/runtime/resources/Messages.properties	Fri Jun 07 17:44:25 2013 +0200
    11.3 @@ -129,6 +129,7 @@
    11.4  type.error.env.not.object=$ENV must be an Object.
    11.5  type.error.unsupported.java.to.type=Unsupported Java.to target type {0}.
    11.6  range.error.inappropriate.array.length=inappropriate array length: {0}
    11.7 +range.error.inappropriate.array.buffer.length=inappropriate array buffer length: {0}
    11.8  range.error.invalid.fraction.digits=fractionDigits argument to {0} must be in [0, 20]
    11.9  range.error.invalid.precision=precision argument toPrecision() must be in [1, 21]
   11.10  range.error.invalid.radix=radix argument must be in [2, 36]

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/test/examples/array-micro.js	Fri Jun 07 17:44:25 2013 +0200
    12.3 @@ -0,0 +1,114 @@
    12.4 +/*
    12.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    12.6 + * 
    12.7 + * Redistribution and use in source and binary forms, with or without
    12.8 + * modification, are permitted provided that the following conditions
    12.9 + * are met:
   12.10 + * 
   12.11 + *   - Redistributions of source code must retain the above copyright
   12.12 + *     notice, this list of conditions and the following disclaimer.
   12.13 + * 
   12.14 + *   - Redistributions in binary form must reproduce the above copyright
   12.15 + *     notice, this list of conditions and the following disclaimer in the
   12.16 + *     documentation and/or other materials provided with the distribution.
   12.17 + * 
   12.18 + *   - Neither the name of Oracle nor the names of its
   12.19 + *     contributors may be used to endorse or promote products derived
   12.20 + *     from this software without specific prior written permission.
   12.21 + * 
   12.22 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   12.23 + * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
   12.24 + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   12.25 + * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
   12.26 + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   12.27 + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   12.28 + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   12.29 + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   12.30 + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   12.31 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   12.32 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   12.33 + */
   12.34 +
   12.35 +
   12.36 +
   12.37 +function bench(name, func) {
   12.38 +    var start = Date.now();
   12.39 +    for (var iter = 0; iter < 5e6; iter++) {
   12.40 +        func();
   12.41 +    }
   12.42 +    print((Date.now() - start) + "\t" + name);
   12.43 +}
   12.44 +
   12.45 +bench("[]", function() {
   12.46 +    [];
   12.47 +    [];
   12.48 +    [];
   12.49 +});
   12.50 +
   12.51 +bench("[1, 2, 3]", function() {
   12.52 +    [1, 2, 3];
   12.53 +    [1, 2, 3];
   12.54 +    [1, 2, 3];
   12.55 +});
   12.56 +
   12.57 +bench("[1 .. 20]", function() {
   12.58 +    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
   12.59 +    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
   12.60 +    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
   12.61 +});
   12.62 +
   12.63 +bench("new Array()", function() {
   12.64 +    new Array();
   12.65 +    new Array();
   12.66 +    new Array();
   12.67 +});
   12.68 +
   12.69 +
   12.70 +bench("new Array(1, 2, 3)", function() {
   12.71 +    new Array(1, 2, 3);
   12.72 +    new Array(1, 2, 3);
   12.73 +    new Array(1, 2, 3);
   12.74 +});
   12.75 +
   12.76 +bench("new Array(10)", function() {
   12.77 +    new Array(10);
   12.78 +    new Array(10);
   12.79 +    new Array(10);
   12.80 +});
   12.81 +
   12.82 +var array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
   12.83 +
   12.84 +bench("get", function() {
   12.85 +    array[0];
   12.86 +    array[3];
   12.87 +    array[6];
   12.88 +});
   12.89 +
   12.90 +bench("set", function() {
   12.91 +    array[0] = 0;
   12.92 +    array[3] = 3;
   12.93 +    array[6] = 6;
   12.94 +});
   12.95 +
   12.96 +var all = function(e) { return true; };
   12.97 +var none = function(e) { return false; };
   12.98 +
   12.99 +bench("filter all", function() {
  12.100 +    array.filter(all);
  12.101 +});
  12.102 +
  12.103 +bench("filter none", function() {
  12.104 +    array.filter(none);
  12.105 +});
  12.106 +
  12.107 +var up = function(a, b) { return a > b ? 1 : -1; };
  12.108 +var down = function(a, b) { return a < b ? 1 : -1; };
  12.109 +
  12.110 +bench("sort up", function() {
  12.111 +    [1, 2, 3, 4].sort(up);
  12.112 +});
  12.113 +
  12.114 +bench("sort down", function() {
  12.115 +    [1, 2, 3, 4].sort(down);
  12.116 +});
  12.117 +

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/test/script/basic/JDK-8012291.js	Fri Jun 07 17:44:25 2013 +0200
    13.3 @@ -0,0 +1,48 @@
    13.4 +/*
    13.5 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    13.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    13.7 + * 
    13.8 + * This code is free software; you can redistribute it and/or modify it
    13.9 + * under the terms of the GNU General Public License version 2 only, as
   13.10 + * published by the Free Software Foundation.
   13.11 + * 
   13.12 + * This code is distributed in the hope that it will be useful, but WITHOUT
   13.13 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13.14 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   13.15 + * version 2 for more details (a copy is included in the LICENSE file that
   13.16 + * accompanied this code).
   13.17 + * 
   13.18 + * You should have received a copy of the GNU General Public License version
   13.19 + * 2 along with this work; if not, write to the Free Software Foundation,
   13.20 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   13.21 + * 
   13.22 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   13.23 + * or visit www.oracle.com if you need additional information or have any
   13.24 + * questions.
   13.25 + */
   13.26 +
   13.27 +/**
   13.28 + * JDK-8012291: NativeArray is inconsistent in using long for length and index in some places and int for the same in other places
   13.29 + *
   13.30 + * @test
   13.31 + * @run
   13.32 + */
   13.33 +
   13.34 +// Make sure JSON parser correctly handles large array keys
   13.35 +var obj = JSON.parse('{"4294967294": 1}');
   13.36 +print(obj[4294967294]);
   13.37 +
   13.38 +// Make sure Array.prototype.sort handles large index correctly
   13.39 +obj.length = 4294967295;
   13.40 +Array.prototype.sort.call(obj);
   13.41 +print(obj[0]);
   13.42 +print(obj[4294967294]);
   13.43 +print(obj.length);
   13.44 +
   13.45 +var arr = [];
   13.46 +arr[4294967294] = 1;
   13.47 +try {
   13.48 +    new Int32Array(arr);
   13.49 +} catch (e) {
   13.50 +    print(e);
   13.51 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/test/script/basic/JDK-8012291.js.EXPECTED	Fri Jun 07 17:44:25 2013 +0200
    14.3 @@ -0,0 +1,5 @@
    14.4 +1
    14.5 +1
    14.6 +undefined
    14.7 +4294967295
    14.8 +RangeError: inappropriate array buffer length: 4294967295