Java Code Examples for jdk.nashorn.internal.codegen.types.Type#NUMBER

static Type getTypeForSlotDescriptor(final char typeDesc) {
    // Recognizing both lowercase and uppercase as we're using both to signify symbol boundaries; see
    // MethodEmitter.markSymbolBoundariesInLvarTypesDescriptor().
    switch (typeDesc) {
        case 'I':
        case 'i':
            return Type.INT;
        case 'J':
        case 'j':
            return Type.LONG;
        case 'D':
        case 'd':
            return Type.NUMBER;
        case 'A':
        case 'a':
            return Type.OBJECT;
        case 'U':
        case 'u':
            return Type.UNKNOWN;
        default:
            throw new AssertionError();
    }
}
 

static Type getTypeForSlotDescriptor(final char typeDesc) {
    // Recognizing both lowercase and uppercase as we're using both to signify symbol boundaries; see
    // MethodEmitter.markSymbolBoundariesInLvarTypesDescriptor().
    switch (typeDesc) {
        case 'I':
        case 'i':
            return Type.INT;
        case 'J':
        case 'j':
            return Type.LONG;
        case 'D':
        case 'd':
            return Type.NUMBER;
        case 'A':
        case 'a':
            return Type.OBJECT;
        case 'U':
        case 'u':
            return Type.UNKNOWN;
        default:
            throw new AssertionError();
    }
}
 

@SuppressWarnings("unused")
private static int ensureInt(final double arg, final int programPoint) {
    if (JSType.isStrictlyRepresentableAsInt(arg)) {
        return (int)arg;
    }
    throw new UnwarrantedOptimismException(arg, programPoint, Type.NUMBER);
}
 

@SuppressWarnings("unused")
private static int ensureInt(final double arg, final int programPoint) {
    if (JSType.isStrictlyRepresentableAsInt(arg)) {
        return (int)arg;
    }
    throw new UnwarrantedOptimismException(arg, programPoint, Type.NUMBER);
}
 

private boolean presetsMatchElementType() {
    if (elementType == Type.INT) {
        return presets instanceof int[];
    } else if (elementType == Type.LONG) {
        return presets instanceof long[];
    } else if (elementType == Type.NUMBER) {
        return presets instanceof double[];
    } else {
        return presets instanceof Object[];
    }
}
 

private boolean presetsMatchElementType() {
    if (elementType == Type.INT) {
        return presets instanceof int[];
    } else if (elementType == Type.NUMBER) {
        return presets instanceof double[];
    } else {
        return presets instanceof Object[];
    }
}
 

private boolean presetsMatchElementType() {
    if (elementType == Type.INT) {
        return presets instanceof int[];
    } else if (elementType == Type.NUMBER) {
        return presets instanceof double[];
    } else {
        return presets instanceof Object[];
    }
}
 

/**
 * Return the widest possible type for this operation. This is used for compile time
 * static type inference
 *
 * @return Type
 */
@Override
public Type getWidestOperationType() {
    switch (tokenType()) {
    case SHR:
    case ASSIGN_SHR:
        return Type.LONG;
    case ASSIGN_SAR:
    case ASSIGN_SHL:
    case BIT_AND:
    case BIT_OR:
    case BIT_XOR:
    case ASSIGN_BIT_AND:
    case ASSIGN_BIT_OR:
    case ASSIGN_BIT_XOR:
    case SAR:
    case SHL:
        return Type.INT;
    case DIV:
    case MOD:
    case MUL:
    case SUB:
    case ASSIGN_DIV:
    case ASSIGN_MOD:
    case ASSIGN_MUL:
    case ASSIGN_SUB:
        return Type.NUMBER;
    default:
        return Type.OBJECT;
    }
}
 

private static Type undefinedToNumber(final Type type) {
    return type == Type.UNDEFINED ? Type.NUMBER : type;
}
 

/**
 * Generate the method that implements the scope get or call.
 */
protected void generateScopeCall() {
    final ClassEmitter classEmitter = compileUnit.getClassEmitter();
    final EnumSet<ClassEmitter.Flag> methodFlags = EnumSet.of(ClassEmitter.Flag.STATIC);

    // This method expects two fixed parameters in addition to any parameters that may be
    // passed on to the function: A ScriptObject representing the caller's current scope object,
    // and an int specifying the distance to the target scope containing the symbol we want to
    // access, or -1 if this is not known at compile time (e.g. because of a "with" or "eval").

    final MethodEmitter method = classEmitter.method(methodFlags, methodName, getStaticSignature());
    method.begin();

    // Load correct scope by calling getProto() on the scope argument as often as specified
    // by the second argument.
    final Label parentLoopStart = new Label("parent_loop_start");
    final Label parentLoopDone  = new Label("parent_loop_done");
    method.load(Type.OBJECT, 0);
    method.label(parentLoopStart);
    method.load(Type.INT, 1);
    method.iinc(1, -1);
    method.ifle(parentLoopDone);
    method.invoke(ScriptObject.GET_PROTO);
    method._goto(parentLoopStart);
    method.label(parentLoopDone);

    method.dynamicGet(valueType, symbol.getName(), flags, isCall);

    // If this is a get we're done, otherwise call the value as function.
    if (isCall) {
        method.convert(Type.OBJECT);
        // ScriptFunction will see CALLSITE_SCOPE and will bind scope accordingly.
        method.loadNull();
        int slot = 2;
        for (final Type type : paramTypes) {
            method.load(type, slot++);
            if (type == Type.NUMBER || type == Type.LONG) {
                slot++;
            }
        }
        method.dynamicCall(returnType, 2 + paramTypes.length, flags);
    }

    method._return(returnType);
    method.end();
}
 

@Override
public Type getWidestOperationType() {
    return isAssignment() ? Type.NUMBER : Type.OBJECT;
}
 

private static Type undefinedToNumber(final Type type) {
    return type == Type.UNDEFINED ? Type.NUMBER : type;
}
 

private static Type undefinedToNumber(final Type type) {
    return type == Type.UNDEFINED ? Type.NUMBER : type;
}
 

@Override
public Type getWidestOperationType() {
    return isAssignment() ? Type.NUMBER : Type.OBJECT;
}
 

/**
 * 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);
}
 

/**
 * 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);
}
 

/**
 * 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);
}
 

/**
 * 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);
}
 

/**
 * Return the type that arithmetic ops should use. Until we have implemented better type
 * analysis (range based) or overflow checks that are fast enough for int arithmetic,
 * this is the number type
 * @return the arithetic type
 */
private static Type arithType() {
    return Compiler.shouldUseIntegerArithmetic() ? Type.INT : Type.NUMBER;
}
 

/**
 * Return the type that arithmetic ops should use. Until we have implemented better type
 * analysis (range based) or overflow checks that are fast enough for int arithmetic,
 * this is the number type
 * @return the arithetic type
 */
private static Type arithType() {
    return Compiler.shouldUseIntegerArithmetic() ? Type.INT : Type.NUMBER;
}