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 
  26 package jdk.nashorn.internal.objects;
  27 
  28 import static jdk.nashorn.internal.codegen.CompilerConstants.specialCall;
  29 
  30 import java.lang.invoke.MethodHandle;
  31 import java.lang.invoke.MethodHandles;
  32 import java.nio.ByteBuffer;
  33 import java.nio.DoubleBuffer;
  34 import jdk.nashorn.internal.objects.annotations.Attribute;
  35 import jdk.nashorn.internal.objects.annotations.Constructor;
  36 import jdk.nashorn.internal.objects.annotations.Function;
  37 import jdk.nashorn.internal.objects.annotations.Property;
  38 import jdk.nashorn.internal.objects.annotations.ScriptClass;
  39 import jdk.nashorn.internal.objects.annotations.Where;
  40 import jdk.nashorn.internal.runtime.JSType;
  41 import jdk.nashorn.internal.runtime.PropertyMap;
  42 import jdk.nashorn.internal.runtime.ScriptObject;
  43 import jdk.nashorn.internal.runtime.arrays.ArrayData;
  44 import jdk.nashorn.internal.runtime.arrays.TypedArrayData;
  45 
  46 /**
  47  * Float64 array for the TypedArray extension
  48  */
  49 @ScriptClass("Float64Array")
  50 public final class NativeFloat64Array extends ArrayBufferView {
  51     /**
  52      * The size in bytes of each element in the array.
  53      */
  54     @Property(attributes = Attribute.NOT_ENUMERABLE | Attribute.NOT_WRITABLE | Attribute.NOT_CONFIGURABLE, where = Where.CONSTRUCTOR)
  55     public static final int BYTES_PER_ELEMENT = 8;
  56 
  57     // initialized by nasgen
  58     @SuppressWarnings("unused")
  59     private static PropertyMap $nasgenmap$;
  60 
  61     private static final Factory FACTORY = new Factory(BYTES_PER_ELEMENT) {
  62         @Override
  63         public ArrayBufferView construct(final NativeArrayBuffer buffer, final int byteOffset, final int length) {
  64             return new NativeFloat64Array(buffer, byteOffset, length);
  65         }
  66 
  67         @Override
  68         public Float64ArrayData createArrayData(final ByteBuffer nb, final int start, final int length) {
  69             return new Float64ArrayData(nb.asDoubleBuffer(), start, length);
  70         }
  71 
  72         @Override
  73         public String getClassName() {
  74             return "Float64Array";
  75         }
  76     };
  77 
  78     private static final class Float64ArrayData extends TypedArrayData<DoubleBuffer> {
  79 
  80         private static final MethodHandle GET_ELEM = specialCall(MethodHandles.lookup(), Float64ArrayData.class, "getElem", double.class, int.class).methodHandle();
  81         private static final MethodHandle SET_ELEM = specialCall(MethodHandles.lookup(), Float64ArrayData.class, "setElem", void.class, int.class, double.class).methodHandle();
  82 
  83         private Float64ArrayData(final DoubleBuffer nb, final int start, final int end) {
  84             super(((DoubleBuffer)nb.position(start).limit(end)).slice(), end - start);
  85         }
  86 
  87         @Override
  88         protected MethodHandle getGetElem() {
  89             return GET_ELEM;
  90         }
  91 
  92         @Override
  93         protected MethodHandle getSetElem() {
  94             return SET_ELEM;
  95         }
  96 
  97         @Override
  98         public Class<?> getElementType() {
  99             return double.class;
 100         }
 101 
 102         @Override
 103         public Class<?> getBoxedElementType() {
 104             return Double.class;
 105         }
 106 
 107         private double getElem(final int index) {
 108             try {
 109                 return nb.get(index);
 110             } catch (final IndexOutOfBoundsException e) {
 111                 throw new ClassCastException(); //force relink - this works for unoptimistic too
 112             }
 113         }
 114 
 115         private void setElem(final int index, final double elem) {
 116             try {
 117                 if (index < nb.limit()) {
 118                     nb.put(index, elem);
 119                 }
 120             } catch (final IndexOutOfBoundsException e) {
 121                 throw new ClassCastException();
 122              }
 123         }
 124 
 125         @Override
 126         public MethodHandle getElementGetter(final Class<?> returnType, final int programPoint) {
 127             if (returnType == int.class) {
 128                 return null;
 129             }
 130             return getContinuousElementGetter(getClass(), GET_ELEM, returnType, programPoint);
 131         }
 132 
 133         @Override
 134         public int getInt(final int index) {
 135             return (int)getDouble(index);
 136         }
 137 
 138         @Override
 139         public double getDouble(final int index) {
 140             return getElem(index);
 141         }
 142 
 143         @Override
 144         public double getDoubleOptimistic(final int index, final int programPoint) {
 145             return getElem(index);
 146         }
 147 
 148         @Override
 149         public Object getObject(final int index) {
 150             return getDouble(index);
 151         }
 152 
 153         @Override
 154         public ArrayData set(final int index, final Object value, final boolean strict) {
 155             return set(index, JSType.toNumber(value), strict);
 156         }
 157 
 158         @Override
 159         public ArrayData set(final int index, final int value, final boolean strict) {
 160             return set(index, (double)value, strict);
 161         }
 162 
 163         @Override
 164         public ArrayData set(final int index, final double value, final boolean strict) {
 165             setElem(index, value);
 166             return this;
 167         }
 168     }
 169 
 170     /**
 171      * Constructor
 172      *
 173      * @param newObj is this typed array instantiated with the new operator
 174      * @param self   self reference
 175      * @param args   args
 176      *
 177      * @return new typed array
 178      */
 179     @Constructor(arity = 1)
 180     public static NativeFloat64Array constructor(final boolean newObj, final Object self, final Object... args) {
 181         return (NativeFloat64Array)constructorImpl(newObj, args, FACTORY);
 182     }
 183 
 184     NativeFloat64Array(final NativeArrayBuffer buffer, final int byteOffset, final int length) {
 185         super(buffer, byteOffset, length);
 186     }
 187 
 188     @Override
 189     protected Factory factory() {
 190         return FACTORY;
 191     }
 192 
 193     @Override
 194     protected boolean isFloatArray() {
 195         return true;
 196     }
 197 
 198     /**
 199      * Set values
 200      * @param self   self reference
 201      * @param array  multiple values of array's type to set
 202      * @param offset optional start index, interpreted  0 if undefined
 203      * @return undefined
 204      */
 205     @Function(attributes = Attribute.NOT_ENUMERABLE)
 206     protected static Object set(final Object self, final Object array, final Object offset) {
 207         return ArrayBufferView.setImpl(self, array, offset);
 208     }
 209 
 210     /**
 211      * Returns a new TypedArray view of the ArrayBuffer store for this TypedArray,
 212      * referencing the elements at begin, inclusive, up to end, exclusive. If either
 213      * begin or end is negative, it refers to an index from the end of the array,
 214      * as opposed to from the beginning.
 215      * <p>
 216      * If end is unspecified, the subarray contains all elements from begin to the end
 217      * of the TypedArray. The range specified by the begin and end values is clamped to
 218      * the valid index range for the current array. If the computed length of the new
 219      * TypedArray would be negative, it is clamped to zero.
 220      * <p>
 221      * The returned TypedArray will be of the same type as the array on which this
 222      * method is invoked.
 223      *
 224      * @param self self reference
 225      * @param begin begin position
 226      * @param end end position
 227      *
 228      * @return sub array
 229      */
 230     @Function(attributes = Attribute.NOT_ENUMERABLE)
 231     protected static NativeFloat64Array subarray(final Object self, final Object begin, final Object end) {
 232         return (NativeFloat64Array)ArrayBufferView.subarrayImpl(self, begin, end);
 233     }
 234 
 235     @Override
 236     protected ScriptObject getPrototype(final Global global) {
 237         return global.getFloat64ArrayPrototype();
 238     }
 239 }