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

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();
    }
}
 

private static Type computeElementType(final Expression[] value) {
    Type widestElementType = Type.INT;

    for (final Expression elem : value) {
        if (elem == null) {
            widestElementType = widestElementType.widest(Type.OBJECT); //no way to represent undefined as number
            break;
        }

        final Type type = elem.getType().isUnknown() ? Type.OBJECT : elem.getType();
        if (type.isBoolean()) {
            //TODO fix this with explicit boolean types
            widestElementType = widestElementType.widest(Type.OBJECT);
            break;
        }

        widestElementType = widestElementType.widest(type);
        if (widestElementType.isObject()) {
            break;
        }
    }
    return widestElementType;
}
 

@Override
public Type getMostOptimisticType() {
    if (CAN_OVERFLOW.contains(tokenType())) {
        return Type.INT;
    }
    return getMostPessimisticType();
}
 

/**
 * Pop a type from the existing stack, ensuring that it is an integer type
 * (integer or long). Boolean type is popped as int type.
 *
 * @return the type
 */
private BitwiseType popBitwise() {
    final Type type = popType();
    if(type == Type.BOOLEAN) {
        return Type.INT;
    }
    return (BitwiseType)type;
}
 

/**
 * Pop a type from the existing stack, ensuring that it is an integer type
 * (integer or long). Boolean type is popped as int type.
 *
 * @return the type
 */
private BitwiseType popBitwise() {
    final Type type = popType();
    if(type == Type.BOOLEAN) {
        return Type.INT;
    }
    return (BitwiseType)type;
}
 

/**
 * Return the widest possible operand type for this operation.
 *
 * @return Type
 */
public Type getWidestOperandType() {
    switch (tokenType()) {
    case SHR:
    case ASSIGN_SHR:
        return Type.INT;
    case INSTANCEOF:
        return Type.OBJECT;
    default:
        if (isComparison()) {
            return Type.OBJECT;
        }
        return getWidestOperationType();
    }
}
 

/**
 * Pop a type from the existing stack, ensuring that it is an integer type
 * (integer or long). Boolean type is popped as int type.
 *
 * @return the type
 */
private BitwiseType popBitwise() {
    final Type type = popType();
    if(type == Type.BOOLEAN) {
        return Type.INT;
    }
    return (BitwiseType)type;
}
 

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[];
    }
}
 

@Override
public Type getMostOptimisticType() {
    final TokenType tokenType = tokenType();
    if(tokenType == TokenType.ADD || tokenType == TokenType.ASSIGN_ADD) {
        return OPTIMISTIC_UNDECIDED_TYPE;
    } else if (CAN_OVERFLOW.contains(tokenType)) {
        return Type.INT;
    }
    return getMostPessimisticType();
}
 

private static Type booleanToInt(final Type type) {
    return type == Type.BOOLEAN ? Type.INT : type;
}
 

@Override
public Type getType() {
    return Type.INT;
}
 

@Override
public Type getMostOptimisticType() {
    return Type.INT;
}
 

@Override
public Type getMostOptimisticType() {
    return Type.INT;
}
 

@Override
public Type getMostOptimisticType() {
    return Type.INT;
}
 

private static Type booleanToInt(final Type type) {
    return type == Type.BOOLEAN ? Type.INT : type;
}
 

@Override
public Type getMostOptimisticType() {
    return Type.INT;
}
 

@Override
public Type getMostOptimisticType() {
    return Type.INT;
}
 

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