/*
* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.nashorn.internal.runtime.arrays;
import jdk.nashorn.internal.runtime.ConsString;
import jdk.nashorn.internal.runtime.JSType;
import jdk.nashorn.internal.runtime.ScriptObject;
/**
* Array index computation helpers. that both throw exceptions or return
* invalid values.
*
*/
public final class ArrayIndex {
private static final int INVALID_ARRAY_INDEX = -1;
private static final long MAX_ARRAY_INDEX = 0xfffffffeL;
private ArrayIndex() {
}
/**
* Fast conversion of non-negative integer string to long.
* @param key Key as a string.
* @return long value of string or {@code -1} if string does not represent a valid index.
*/
private static long fromString(final String key) {
long value = 0;
final int length = key.length();
// Check for empty string or leading 0
if (length == 0 || (length > 1 && key.charAt(0) == '0')) {
return INVALID_ARRAY_INDEX;
}
// Fast toNumber.
for (int i = 0; i < length; i++) {
final char digit = key.charAt(i);
// If not a digit.
if (digit < '0' || digit > '9') {
return INVALID_ARRAY_INDEX;
}
// Insert digit.
value = value * 10 + digit - '0';
// Check for overflow (need to catch before wrap around.)
if (value > MAX_ARRAY_INDEX) {
return INVALID_ARRAY_INDEX;
}
}
return value;
}
/**
* Returns a valid array index in an int, if the object represents one. This
* routine needs to perform quickly since all keys are tested with it.
*
* <p>The {@code key} parameter must be a JavaScript primitive type, i.e. one of
* {@code String}, {@code Number}, {@code Boolean}, {@code null}, or {@code undefined}.
* {@code ScriptObject} instances should be converted to primitive with
* {@code String.class} hint before being passed to this method.</p>
*
* @param key key to check for array index.
* @return the array index, or {@code -1} if {@code key} does not represent a valid index.
* Note that negative return values other than {@code -1} are considered valid and can be converted to
* the actual index using {@link #toLongIndex(int)}.
*/
public static int getArrayIndex(final Object key) {
if (key instanceof Integer) {
return getArrayIndex(((Integer) key).intValue());
} else if (key instanceof Double) {
return getArrayIndex(((Double) key).doubleValue());
} else if (key instanceof String) {
return (int)fromString((String) key);
} else if (key instanceof Long) {
return getArrayIndex(((Long) key).longValue());
} else if (key instanceof ConsString) {
return (int)fromString(key.toString());
}
assert !(key instanceof ScriptObject);
return INVALID_ARRAY_INDEX;
}
/**
* Returns a valid array index in an int, if {@code key} represents one.
*
* @param key key to check
* @return the array index, or {@code -1} if {@code key} is not a valid array index.
*/
public static int getArrayIndex(final int key) {
return (key >= 0) ? key : INVALID_ARRAY_INDEX;
}
/**
* Returns a valid array index in an int, if the long represents one.
*
* @param key key to check
* @return the array index, or {@code -1} if long is not a valid array index.
* Note that negative return values other than {@code -1} are considered valid and can be converted to
* the actual index using {@link #toLongIndex(int)}.
*/
public static int getArrayIndex(final long key) {
if (key >= 0 && key <= MAX_ARRAY_INDEX) {
return (int)key;
}
return INVALID_ARRAY_INDEX;
}
/**
* Return a valid index for this double, if it represents one.
*
* Doubles that aren't representable exactly as longs/ints aren't working
* array indexes, however, array[1.1] === array["1.1"] in JavaScript.
*
* @param key the key to check
* @return the array index this double represents or {@code -1} if this isn't a valid index.
* Note that negative return values other than {@code -1} are considered valid and can be converted to
* the actual index using {@link #toLongIndex(int)}.
*/
public static int getArrayIndex(final double key) {
if (JSType.isRepresentableAsInt(key)) {
return getArrayIndex((int) key);
} else if (JSType.isRepresentableAsLong(key)) {
return getArrayIndex((long) key);
}
return INVALID_ARRAY_INDEX;
}
/**
* Return a valid array index for this string, if it represents one.
*
* @param key the key to check
* @return the array index this string represents or {@code -1} if this isn't a valid index.
* Note that negative return values other than {@code -1} are considered valid and can be converted to
* the actual index using {@link #toLongIndex(int)}.
*/
public static int getArrayIndex(final String key) {
return (int)fromString(key);
}
/**
* Check whether an index is valid as an array index. This check only tests if
* it is the special "invalid array index" type, not if it is e.g. less than zero
* or corrupt in some other way
*
* @param index index to test
* @return true if {@code index} is not the special invalid array index type
*/
public static boolean isValidArrayIndex(final int index) {
return index != INVALID_ARRAY_INDEX;
}
/**
* Convert an index to a long value. This basically amounts to converting it into a
* {@link JSType#toUint32(int)} uint32} as the maximum array index in JavaScript
* is 0xfffffffe
*
* @param index index to convert to long form
* @return index as uint32 in a long
*/
public static long toLongIndex(final int index) {
return JSType.toUint32(index);
}
/**
* Convert an index to a key string. This is the same as calling {@link #toLongIndex(int)}
* and converting the result to String.
*
* @param index index to convert
* @return index as string
*/
public static String toKey(final int index) {
return Long.toString(JSType.toUint32(index));
}
}