import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * ECMA 15.7.4.5 Number.prototype.toFixed (fractionDigits) specialized for int fractionDigits
 *
 * @param self           self reference
 * @param fractionDigits how many digits should be after the decimal point, 0 if undefined
 *
 * @return number in decimal fixed point notation
 */
@SpecializedFunction
public static String toFixed(final Object self, final int fractionDigits) {
    if (fractionDigits < 0 || fractionDigits > 20) {
        throw rangeError("invalid.fraction.digits", "toFixed");
    }

    final double x = getNumberValue(self);
    if (Double.isNaN(x)) {
        return "NaN";
    }

    if (Math.abs(x) >= 1e21) {
        return JSType.toString(x);
    }

    final NumberFormat format = NumberFormat.getNumberInstance(Locale.US);
    format.setMinimumFractionDigits(fractionDigits);
    format.setMaximumFractionDigits(fractionDigits);
    format.setGroupingUsed(false);

    return format.format(x);
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * ECMA 15.4.4.4 Array.prototype.concat ( [ item1 [ , item2 [ , ... ] ] ] )
 *
 * @param self self reference
 * @param arg argument
 * @return resulting NativeArray
 */
@SpecializedFunction(linkLogic=ConcatLinkLogic.class)
public static NativeArray concat(final Object self, final Object arg) {
    //arg is [NativeArray] of same type.
    final ContinuousArrayData selfData = getContinuousArrayDataCCE(self);
    final ContinuousArrayData newData;

    if (arg instanceof NativeArray) {
        final ContinuousArrayData argData = (ContinuousArrayData)((NativeArray)arg).getArray();
        if (argData.isEmpty()) {
            newData = selfData.copy();
        } else if (selfData.isEmpty()) {
            newData = argData.copy();
        } else {
            final Class<?> widestElementType = selfData.widest(argData).getBoxedElementType();
            newData = ((ContinuousArrayData)selfData.convert(widestElementType)).fastConcat((ContinuousArrayData)argData.convert(widestElementType));
        }
    } else {
        newData = getContinuousArrayDataCCE(self, Object.class).copy();
        newData.fastPush(arg);
    }

    return new NativeArray(newData);
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * ECMA 15.7.4.5 Number.prototype.toFixed (fractionDigits) specialized for int fractionDigits
 *
 * @param self           self reference
 * @param fractionDigits how many digits should be after the decimal point, 0 if undefined
 *
 * @return number in decimal fixed point notation
 */
@SpecializedFunction
public static String toFixed(final Object self, final int fractionDigits) {
    if (fractionDigits < 0 || fractionDigits > 20) {
        throw rangeError("invalid.fraction.digits", "toFixed");
    }

    final double x = getNumberValue(self);
    if (Double.isNaN(x)) {
        return "NaN";
    }

    if (Math.abs(x) >= 1e21) {
        return JSType.toString(x);
    }

    return DoubleConversion.toFixed(x, fractionDigits);
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * ECMA 15.5.3.2 - specialization for one char
 * @param self  self reference
 * @param value one argument to be interpreted as char
 * @return string with one charcode
 */
@SpecializedFunction
public static Object fromCharCode(final Object self, final Object value) {
    if (value instanceof Integer) {
        return fromCharCode(self, (int)value);
    }
    return Character.toString((char)JSType.toUint16(value));
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Get 32-bit signed int from given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to read from
 * @return 32-bit signed int value at the byteOffset
 */
@SpecializedFunction
public static int getInt32(final Object self, final int byteOffset) {
    try {
        return getBuffer(self, false).getInt(byteOffset);
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * ECMA 15.5.4.13 String.prototype.slice (start, end) specialized for single int parameter
 *
 * @param self  self reference
 * @param start start position for slice
 * @return sliced out substring
 */
@SpecializedFunction
public static String slice(final Object self, final int start) {
    final String str = checkObjectToString(self);
    final int from = start < 0 ? Math.max(str.length() + start, 0) : Math.min(start, str.length());

    return str.substring(from);
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * ECMA 15.5.4.15 String.prototype.substring (start, end) specialized for int start parameter
 *
 * @param self  self reference
 * @param start start position of substring
 * @return substring given start and end indexes
 */
@SpecializedFunction
public static String substring(final Object self, final int start) {
    final String str = checkObjectToString(self);
    if (start < 0) {
        return str;
    } else if (start >= str.length()) {
        return "";
    } else {
        return str.substring(start);
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Set 16-bit signed int at the given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to write at
 * @param value short value to set
 * @param littleEndian (optional) flag indicating whether to write in little endian order
 * @return undefined
 */
@SpecializedFunction
public static Object setInt16(final Object self, final int byteOffset, final int value, final boolean littleEndian) {
    try {
        getBuffer(self, littleEndian).putShort(byteOffset, (short)value);
        return UNDEFINED;
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Get 32-bit float value from given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to read from
 * @return 32-bit float value at the byteOffset
 */
@SpecializedFunction
public static double getFloat32(final Object self, final int byteOffset) {
    try {
        return getBuffer(self, false).getFloat(byteOffset);
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * ECMA 15.4.2.2 new Array (len)
 *
 * Specialized constructor for one double argument (length)
 *
 * @param newObj was the new operator used to instantiate this array
 * @param self   self reference
 * @param length array length
 * @return the new NativeArray
 */
@SpecializedFunction(isConstructor=true)
public static NativeArray construct(final boolean newObj, final Object self, final double length) {
    final long uint32length = JSType.toUint32(length);

    if (uint32length == length) {
        return new NativeArray(uint32length);
    }

    return construct(newObj, self, new Object[]{length});
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Set 32-bit float at the given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to write at
 * @param value float value to set
 * @param littleEndian (optional) flag indicating whether to write in little endian order
 * @return undefined
 */
@SpecializedFunction
public static Object setFloat32(final Object self, final int byteOffset, final double value, final boolean littleEndian) {
    try {
        getBuffer(self, littleEndian).putFloat(byteOffset, (float)value);
        return UNDEFINED;
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Set 32-bit unsigned int at the given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to write at
 * @param value int value to set
 * @return undefined
 */
@SpecializedFunction
public static Object setUint32(final Object self, final int byteOffset, final double value) {
    try {
        getBuffer(self, false).putInt(byteOffset, (int) JSType.toUint32(value));
        return UNDEFINED;
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Get 64-bit float value from given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to read from
 * @return 64-bit float value at the byteOffset
 */
@SpecializedFunction
public static double getFloat64(final Object self, final int byteOffset) {
    try {
        return getBuffer(self, false).getDouble(byteOffset);
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Get 8-bit signed int from given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to read from
 * @return 8-bit signed int value at the byteOffset
 */
@SpecializedFunction
public static int getInt8(final Object self, final int byteOffset) {
    try {
        return getBuffer(self).get(byteOffset);
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
@Override
public SpecializedFunction.LinkLogic getLinkLogic(final Class<? extends LinkLogic> clazz) {
    if (clazz == PushLinkLogic.class) {
        return PushLinkLogic.INSTANCE;
    } else if (clazz == PopLinkLogic.class) {
        return PopLinkLogic.INSTANCE;
    } else if (clazz == ConcatLinkLogic.class) {
        return ConcatLinkLogic.INSTANCE;
    }
    return null;
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Get 16-bit signed int from given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to read from
 * @param littleEndian (optional) flag indicating whether to read in little endian order
 * @return 16-bit signed int value at the byteOffset
 */
@SpecializedFunction
public static int getInt16(final Object self, final int byteOffset, final boolean littleEndian) {
    try {
        return getBuffer(self, littleEndian).getShort(byteOffset);
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Get 16-bit unsigned int from given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to read from
 * @param littleEndian (optional) flag indicating whether to read in little endian order
 * @return 16-bit unsigned int value at the byteOffset
 */
@SpecializedFunction
public static int getUint16(final Object self, final int byteOffset, final boolean littleEndian) {
    try {
        return 0xFFFF & getBuffer(self, littleEndian).getShort(byteOffset);
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Get 16-bit unsigned int from given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to read from
 * @return 16-bit unsigned int value at the byteOffset
 */
@SpecializedFunction
public static int getUint16(final Object self, final int byteOffset) {
    try {
        return 0xFFFF & getBuffer(self, false).getShort(byteOffset);
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Set 16-bit signed int at the given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to write at
 * @param value short value to set
 * @return undefined
 */
@SpecializedFunction
public static Object setInt16(final Object self, final int byteOffset, final int value) {
    try {
        getBuffer(self, false).putShort(byteOffset, (short)value);
        return UNDEFINED;
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}
 

import jdk.nashorn.internal.objects.annotations.SpecializedFunction; //导入依赖的package包/类
/**
 * Set 16-bit unsigned int at the given byteOffset
 *
 * @param self DataView object
 * @param byteOffset byte offset to write at
 * @param value short value to set
 * @param littleEndian (optional) flag indicating whether to write in little endian order
 * @return undefined
 */
@SpecializedFunction
public static Object setUint16(final Object self, final int byteOffset, final int value, final boolean littleEndian) {
    try {
        getBuffer(self, littleEndian).putShort(byteOffset, (short)value);
        return UNDEFINED;
    } catch (final IllegalArgumentException iae) {
        throw rangeError(iae, "dataview.offset");
    }
}