ObjectArrayData.java revision 1056:e0b9b2ef8442
1/* 2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26package jdk.nashorn.internal.runtime.arrays; 27 28import static jdk.nashorn.internal.codegen.CompilerConstants.specialCall; 29import java.lang.invoke.MethodHandle; 30import java.lang.invoke.MethodHandles; 31import java.util.Arrays; 32import jdk.nashorn.internal.codegen.types.Type; 33import jdk.nashorn.internal.runtime.JSType; 34import jdk.nashorn.internal.runtime.ScriptRuntime; 35 36/** 37 * Implementation of {@link ArrayData} as soon as an Object has been 38 * written to the array 39 */ 40final class ObjectArrayData extends ContinuousArrayData { 41 42 /** 43 * The wrapped array 44 */ 45 private Object[] array; 46 47 /** 48 * Constructor 49 * @param array an int array 50 * @param length a length, not necessarily array.length 51 */ 52 ObjectArrayData(final Object array[], final int length) { 53 super(length); 54 assert array.length >= length; 55 this.array = array; 56 } 57 58 @Override 59 public Class<?> getElementType() { 60 return Object.class; 61 } 62 63 @Override 64 public ArrayData copy() { 65 return new ObjectArrayData(array.clone(), (int)length); 66 } 67 68 @Override 69 public Object[] asObjectArray() { 70 return array.length == length ? array.clone() : asObjectArrayCopy(); 71 } 72 73 private Object[] asObjectArrayCopy() { 74 final long len = length; 75 assert len <= Integer.MAX_VALUE; 76 final Object[] copy = new Object[(int)len]; 77 System.arraycopy(array, 0, copy, 0, (int)len); 78 return copy; 79 } 80 81 @Override 82 public ArrayData convert(final Class<?> type) { 83 return this; 84 } 85 86 @Override 87 public void shiftLeft(final int by) { 88 System.arraycopy(array, by, array, 0, array.length - by); 89 } 90 91 @Override 92 public ArrayData shiftRight(final int by) { 93 final ArrayData newData = ensure(by + length - 1); 94 if (newData != this) { 95 newData.shiftRight(by); 96 return newData; 97 } 98 System.arraycopy(array, 0, array, by, array.length - by); 99 return this; 100 } 101 102 @Override 103 public ArrayData ensure(final long safeIndex) { 104 if (safeIndex >= SparseArrayData.MAX_DENSE_LENGTH) { 105 return new SparseArrayData(this, safeIndex + 1); 106 } 107 final int alen = array.length; 108 if (safeIndex >= alen) { 109 final int newLength = ArrayData.nextSize((int)safeIndex); 110 array = Arrays.copyOf(array, newLength); //fill with undefined or OK? TODO 111 } 112 setLength(safeIndex + 1); 113 return this; 114 } 115 116 @Override 117 public ArrayData shrink(final long newLength) { 118 Arrays.fill(array, (int) newLength, array.length, ScriptRuntime.UNDEFINED); 119 return this; 120 } 121 122 @Override 123 public ArrayData set(final int index, final Object value, final boolean strict) { 124 array[index] = value; 125 setLength(Math.max(index + 1, length)); 126 return this; 127 } 128 129 @Override 130 public ArrayData set(final int index, final int value, final boolean strict) { 131 array[index] = value; 132 setLength(Math.max(index + 1, length)); 133 return this; 134 } 135 136 @Override 137 public ArrayData set(final int index, final long value, final boolean strict) { 138 array[index] = value; 139 setLength(Math.max(index + 1, length)); 140 return this; 141 } 142 143 @Override 144 public ArrayData set(final int index, final double value, final boolean strict) { 145 array[index] = value; 146 setLength(Math.max(index + 1, length)); 147 return this; 148 } 149 150 @Override 151 public ArrayData setEmpty(final int index) { 152 array[index] = ScriptRuntime.EMPTY; 153 return this; 154 } 155 156 @Override 157 public ArrayData setEmpty(final long lo, final long hi) { 158 // hi parameter is inclusive, but Arrays.fill toIndex parameter is exclusive 159 Arrays.fill(array, (int)Math.max(lo, 0L), (int)Math.min(hi + 1, Integer.MAX_VALUE), ScriptRuntime.EMPTY); 160 return this; 161 } 162 163 @Override 164 public Type getOptimisticType() { 165 return Type.OBJECT; 166 } 167 168 private static final MethodHandle HAS_GET_ELEM = specialCall(MethodHandles.lookup(), ObjectArrayData.class, "getElem", Object.class, int.class).methodHandle(); 169 private static final MethodHandle SET_ELEM = specialCall(MethodHandles.lookup(), ObjectArrayData.class, "setElem", void.class, int.class, Object.class).methodHandle(); 170 171 @SuppressWarnings("unused") 172 private Object getElem(final int index) { 173 if (has(index)) { 174 return array[index]; 175 } 176 throw new ClassCastException(); 177 } 178 179 @SuppressWarnings("unused") 180 private void setElem(final int index, final Object elem) { 181 if (hasRoomFor(index)) { 182 array[index] = elem; 183 return; 184 } 185 throw new ClassCastException(); 186 } 187 188 @Override 189 public MethodHandle getElementGetter(final Class<?> returnType, final int programPoint) { 190 if (returnType.isPrimitive()) { 191 return null; 192 } 193 return getContinuousElementGetter(HAS_GET_ELEM, returnType, programPoint); 194 } 195 196 @Override 197 public MethodHandle getElementSetter(final Class<?> elementType) { 198 return getContinuousElementSetter(SET_ELEM, Object.class); 199 } 200 201 202 @Override 203 public int getInt(final int index) { 204 return JSType.toInt32(array[index]); 205 } 206 207 @Override 208 public long getLong(final int index) { 209 return JSType.toLong(array[index]); 210 } 211 212 @Override 213 public double getDouble(final int index) { 214 return JSType.toNumber(array[index]); 215 } 216 217 @Override 218 public Object getObject(final int index) { 219 return array[index]; 220 } 221 222 @Override 223 public boolean has(final int index) { 224 return 0 <= index && index < length; 225 } 226 227 @Override 228 public ArrayData delete(final int index) { 229 setEmpty(index); 230 return new DeletedRangeArrayFilter(this, index, index); 231 } 232 233 @Override 234 public ArrayData delete(final long fromIndex, final long toIndex) { 235 setEmpty(fromIndex, toIndex); 236 return new DeletedRangeArrayFilter(this, fromIndex, toIndex); 237 } 238 239 @Override 240 public long fastPush(final int arg) { 241 return fastPush((Object)arg); 242 } 243 244 @Override 245 public long fastPush(final long arg) { 246 return fastPush((Object)arg); 247 } 248 249 @Override 250 public long fastPush(final double arg) { 251 return fastPush((Object)arg); 252 } 253 254 @Override 255 public long fastPush(final Object arg) { 256 final int len = (int)length; 257 if (len == array.length) { 258 array = Arrays.copyOf(array, nextSize(len)); 259 } 260 array[len] = arg; 261 return ++length; 262 } 263 264 @Override 265 public Object fastPopObject() { 266 if (length == 0) { 267 return ScriptRuntime.UNDEFINED; 268 } 269 final int newLength = (int)--length; 270 final Object elem = array[newLength]; 271 array[newLength] = ScriptRuntime.EMPTY; 272 return elem; 273 } 274 275 @Override 276 public Object pop() { 277 if (length == 0) { 278 return ScriptRuntime.UNDEFINED; 279 } 280 281 final int newLength = (int)length - 1; 282 final Object elem = array[newLength]; 283 setEmpty(newLength); 284 setLength(newLength); 285 return elem; 286 } 287 288 @Override 289 public ArrayData slice(final long from, final long to) { 290 final long start = from < 0 ? from + length : from; 291 final long newLength = to - start; 292 return new ObjectArrayData(Arrays.copyOfRange(array, (int)from, (int)to), (int)newLength); 293 } 294 295 @Override 296 public ArrayData push(final boolean strict, final Object item) { 297 final long len = length; 298 final ArrayData newData = ensure(len); 299 if (newData == this) { 300 array[(int)len] = item; 301 return this; 302 } 303 return newData.set((int)len, item, strict); 304 } 305 306 @Override 307 public ArrayData fastSplice(final int start, final int removed, final int added) throws UnsupportedOperationException { 308 final long oldLength = length; 309 final long newLength = oldLength - removed + added; 310 if (newLength > SparseArrayData.MAX_DENSE_LENGTH && newLength > array.length) { 311 throw new UnsupportedOperationException(); 312 } 313 final ArrayData returnValue = removed == 0 ? 314 EMPTY_ARRAY : new ObjectArrayData(Arrays.copyOfRange(array, start, start + removed), removed); 315 316 if (newLength != oldLength) { 317 final Object[] newArray; 318 319 if (newLength > array.length) { 320 newArray = new Object[ArrayData.nextSize((int)newLength)]; 321 System.arraycopy(array, 0, newArray, 0, start); 322 } else { 323 newArray = array; 324 } 325 326 System.arraycopy(array, start + removed, newArray, start + added, (int)(oldLength - start - removed)); 327 array = newArray; 328 setLength(newLength); 329 } 330 331 return returnValue; 332 } 333} 334