| /* |
| * 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; |
| |
| import java.io.NotSerializableException; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import jdk.nashorn.internal.codegen.types.Type; |
| |
| /** |
| * This exception is thrown from an optimistic operation, e.g. an integer add, |
| * that was to optimistic for what really took place. Typically things like |
| * trying to get an array element that we want to be an int, and it was a double, |
| * and an int add that actually overflows and needs a double for the representation |
| */ |
| |
| @SuppressWarnings("serial") |
| public final class UnwarrantedOptimismException extends RuntimeException { |
| /** Denotes an invalid program point */ |
| public static final int INVALID_PROGRAM_POINT = -1; |
| |
| /** The value for the first ordinary program point */ |
| public static final int FIRST_PROGRAM_POINT = 1; |
| |
| private Object returnValue; |
| private final int programPoint; |
| private final Type returnType; |
| |
| /** |
| * Constructor without explicit return type. The return type is determined statically from the class of |
| * the return value, and only canonical internal number representations are recognized. Use |
| * {@link #createNarrowest} if you want to handle float and long values as numbers instead of objects. |
| * |
| * @param returnValue actual return value from the too narrow operation |
| * @param programPoint program point where unwarranted optimism was detected |
| */ |
| public UnwarrantedOptimismException(final Object returnValue, final int programPoint) { |
| this(returnValue, programPoint, getReturnType(returnValue)); |
| } |
| |
| /** |
| * Check if a program point is valid. |
| * @param programPoint the program point |
| * @return true if valid |
| */ |
| public static boolean isValid(final int programPoint) { |
| assert programPoint >= INVALID_PROGRAM_POINT; |
| return programPoint != INVALID_PROGRAM_POINT; |
| } |
| |
| private static Type getReturnType(final Object v) { |
| if (v instanceof Double) { |
| return Type.NUMBER; |
| } |
| assert !(v instanceof Integer) : v + " is an int"; // Can't have an unwarranted optimism exception with int |
| return Type.OBJECT; |
| } |
| |
| /** |
| * Constructor with explicit return value type. |
| * @param returnValue actual return value from the too narrow operation |
| * @param programPoint program point where unwarranted optimism was detected |
| * @param returnType type of the returned value. Used to disambiguate the return type. E.g. an {@code ObjectArrayData} |
| * might return a {@link Double} for a particular element getter, but still throw this exception even if the call |
| * site can accept a double, since the array's type is actually {@code Type#OBJECT}. In this case, it must |
| * explicitly use this constructor to indicate its values are to be considered {@code Type#OBJECT} and not |
| * {@code Type#NUMBER}. |
| */ |
| public UnwarrantedOptimismException(final Object returnValue, final int programPoint, final Type returnType) { |
| super("", null, false, Context.DEBUG); |
| assert returnType != Type.OBJECT || returnValue == null || !Type.typeFor(returnValue.getClass()).isNumeric(); |
| assert returnType != Type.INT; |
| this.returnValue = returnValue; |
| this.programPoint = programPoint; |
| this.returnType = returnType; |
| } |
| |
| /** |
| * Create an {@code UnwarrantedOptimismException} with the given return value and program point, narrowing |
| * the type to {@code number} if the value is a float or a long that can be represented as double. |
| * |
| * @param returnValue the return value |
| * @param programPoint the program point |
| * @return the exception |
| */ |
| public static UnwarrantedOptimismException createNarrowest(final Object returnValue, final int programPoint) { |
| if (returnValue instanceof Float |
| || (returnValue instanceof Long && JSType.isRepresentableAsDouble((Long) returnValue))) { |
| return new UnwarrantedOptimismException(((Number) returnValue).doubleValue(), programPoint, Type.NUMBER); |
| } |
| return new UnwarrantedOptimismException(returnValue, programPoint); |
| } |
| |
| /** |
| * Get the return value. This is a destructive readout, after the method is invoked the return value is null'd out. |
| * @return return value |
| */ |
| public Object getReturnValueDestructive() { |
| final Object retval = returnValue; |
| returnValue = null; |
| return retval; |
| } |
| |
| Object getReturnValueNonDestructive() { |
| return returnValue; |
| } |
| |
| /** |
| * Get the return type |
| * @return return type |
| */ |
| public Type getReturnType() { |
| return returnType; |
| } |
| |
| /** |
| * Does this exception refer to an invalid program point? This might be OK if |
| * we throw it, e.g. from a parameter guard |
| * @return true if invalid program point specified |
| */ |
| public boolean hasInvalidProgramPoint() { |
| return programPoint == INVALID_PROGRAM_POINT; |
| } |
| |
| /** |
| * Get the program point |
| * @return the program point |
| */ |
| public int getProgramPoint() { |
| return programPoint; |
| } |
| |
| /** |
| * Check if we ended up with a primitive return value (even though it may be |
| * too wide for what we tried to do, e.g. double instead of int) |
| * @return true if return value is primitive |
| */ |
| public boolean hasPrimitiveReturnValue() { |
| return returnValue instanceof Number || returnValue instanceof Boolean; |
| } |
| |
| @Override |
| public String getMessage() { |
| return "UNWARRANTED OPTIMISM: [returnValue=" + |
| returnValue + |
| " (class=" + |
| (returnValue == null ? "null" : returnValue.getClass().getSimpleName()) + |
| (hasInvalidProgramPoint() ? |
| " <invalid program point>" : |
| (" @ program point #" + programPoint)) + |
| ")]"; |
| } |
| |
| |
| private void writeObject(final ObjectOutputStream out) throws NotSerializableException { |
| throw new NotSerializableException(getClass().getName()); |
| } |
| |
| private void readObject(final ObjectInputStream in) throws NotSerializableException { |
| throw new NotSerializableException(getClass().getName()); |
| } |
| } |