sun.invoke.util.VerifyType Java Examples

The following examples show how to use sun.invoke.util.VerifyType. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.

Example #1

Source File: MethodType.java From hottub with GNU General Public License v2.0

6 votes

/** True if the new parameters can be viewed (w/o casting) under the old parameter types. */
/*non-public*/
boolean parametersAreViewableAs(MethodType newType, boolean keepInterfaces) {
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #2

Source File: MethodType.java From jdk1.8-source-analysis with Apache License 2.0

6 votes

/** True if the new parameters can be viewed (w/o casting) under the old parameter types. */
/*non-public*/
boolean parametersAreViewableAs(MethodType newType, boolean keepInterfaces) {
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #3

Source File: MethodType.java From TencentKona-8 with GNU General Public License v2.0

6 votes

/** True if the new parameters can be viewed (w/o casting) under the old parameter types. */
/*non-public*/
boolean parametersAreViewableAs(MethodType newType, boolean keepInterfaces) {
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #4

Source File: MethodType.java From jdk8u-dev-jdk with GNU General Public License v2.0

6 votes

/** True if the new parameters can be viewed (w/o casting) under the old parameter types. */
/*non-public*/
boolean parametersAreViewableAs(MethodType newType, boolean keepInterfaces) {
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #5

Source File: InvokerBytecodeGenerator.java From TencentKona-8 with GNU General Public License v2.0

6 votes

/**
 * Emit an implicit conversion for an argument which must be of the given pclass.
 * This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.
 *
 * @param ptype type of value present on stack
 * @param pclass type of value required on stack
 * @param arg compile-time representation of value on stack (Node, constant) or null if none
 */
private void emitImplicitConversion(BasicType ptype, Class<?> pclass, Object arg) {
    assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
    if (pclass == ptype.basicTypeClass() && ptype != L_TYPE)
        return;   // nothing to do
    switch (ptype) {
        case L_TYPE:
            if (VerifyType.isNullConversion(Object.class, pclass, false)) {
                if (PROFILE_LEVEL > 0)
                    emitReferenceCast(Object.class, arg);
                return;
            }
            emitReferenceCast(pclass, arg);
            return;
        case I_TYPE:
            if (!VerifyType.isNullConversion(int.class, pclass, false))
                emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
            return;
    }
    throw newInternalError("bad implicit conversion: tc="+ptype+": "+pclass);
}

Example #6

Source File: MethodType.java From jdk8u60 with GNU General Public License v2.0

6 votes

/** True if the new parameters can be viewed (w/o casting) under the old parameter types. */
/*non-public*/
boolean parametersAreViewableAs(MethodType newType, boolean keepInterfaces) {
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #7

Source File: MethodType.java From JDKSourceCode1.8 with MIT License

6 votes

/** True if the new parameters can be viewed (w/o casting) under the old parameter types. */
/*non-public*/
boolean parametersAreViewableAs(MethodType newType, boolean keepInterfaces) {
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #8

Source File: InvokerBytecodeGenerator.java From JDKSourceCode1.8 with MIT License

6 votes

/**
 * Emit an implicit conversion for an argument which must be of the given pclass.
 * This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.
 *
 * @param ptype type of value present on stack
 * @param pclass type of value required on stack
 * @param arg compile-time representation of value on stack (Node, constant) or null if none
 */
private void emitImplicitConversion(BasicType ptype, Class<?> pclass, Object arg) {
    assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
    if (pclass == ptype.basicTypeClass() && ptype != L_TYPE)
        return;   // nothing to do
    switch (ptype) {
        case L_TYPE:
            if (VerifyType.isNullConversion(Object.class, pclass, false)) {
                if (PROFILE_LEVEL > 0)
                    emitReferenceCast(Object.class, arg);
                return;
            }
            emitReferenceCast(pclass, arg);
            return;
        case I_TYPE:
            if (!VerifyType.isNullConversion(int.class, pclass, false))
                emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
            return;
    }
    throw newInternalError("bad implicit conversion: tc="+ptype+": "+pclass);
}

Example #9

Source File: MethodType.java From openjdk-jdk8u with GNU General Public License v2.0

6 votes

/** True if the new parameters can be viewed (w/o casting) under the old parameter types. */
/*non-public*/
boolean parametersAreViewableAs(MethodType newType, boolean keepInterfaces) {
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #10

Source File: MethodType.java From Bytecoder with Apache License 2.0

6 votes

/** True if the old return type can always be viewed (w/o casting) under new return type,
 *  and the new parameters can be viewed (w/o casting) under the old parameter types.
 */
/*non-public*/
boolean isViewableAs(MethodType newType, boolean keepInterfaces) {
    if (!VerifyType.isNullConversion(returnType(), newType.returnType(), keepInterfaces))
        return false;
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #11

Source File: InvokerBytecodeGenerator.java From Bytecoder with Apache License 2.0

6 votes

/**
 * Emit an implicit conversion for an argument which must be of the given pclass.
 * This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.
 *
 * @param ptype type of value present on stack
 * @param pclass type of value required on stack
 * @param arg compile-time representation of value on stack (Node, constant) or null if none
 */
private void emitImplicitConversion(BasicType ptype, Class<?> pclass, Object arg) {
    assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
    if (pclass == ptype.basicTypeClass() && ptype != L_TYPE)
        return;   // nothing to do
    switch (ptype) {
        case L_TYPE:
            if (VerifyType.isNullConversion(Object.class, pclass, false)) {
                if (PROFILE_LEVEL > 0)
                    emitReferenceCast(Object.class, arg);
                return;
            }
            emitReferenceCast(pclass, arg);
            return;
        case I_TYPE:
            if (!VerifyType.isNullConversion(int.class, pclass, false))
                emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
            return;
    }
    throw newInternalError("bad implicit conversion: tc="+ptype+": "+pclass);
}

Example #12

Source File: MethodType.java From openjdk-jdk9 with GNU General Public License v2.0

6 votes

/** True if the old return type can always be viewed (w/o casting) under new return type,
 *  and the new parameters can be viewed (w/o casting) under the old parameter types.
 */
/*non-public*/
boolean isViewableAs(MethodType newType, boolean keepInterfaces) {
    if (!VerifyType.isNullConversion(returnType(), newType.returnType(), keepInterfaces))
        return false;
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #13

Source File: InvokerBytecodeGenerator.java From openjdk-jdk9 with GNU General Public License v2.0

6 votes

/**
 * Emit an implicit conversion for an argument which must be of the given pclass.
 * This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.
 *
 * @param ptype type of value present on stack
 * @param pclass type of value required on stack
 * @param arg compile-time representation of value on stack (Node, constant) or null if none
 */
private void emitImplicitConversion(BasicType ptype, Class<?> pclass, Object arg) {
    assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
    if (pclass == ptype.basicTypeClass() && ptype != L_TYPE)
        return;   // nothing to do
    switch (ptype) {
        case L_TYPE:
            if (VerifyType.isNullConversion(Object.class, pclass, false)) {
                if (PROFILE_LEVEL > 0)
                    emitReferenceCast(Object.class, arg);
                return;
            }
            emitReferenceCast(pclass, arg);
            return;
        case I_TYPE:
            if (!VerifyType.isNullConversion(int.class, pclass, false))
                emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
            return;
    }
    throw newInternalError("bad implicit conversion: tc="+ptype+": "+pclass);
}

Example #14

Source File: InvokerBytecodeGenerator.java From jdk8u-jdk with GNU General Public License v2.0

6 votes

/**
 * Emit an implicit conversion for an argument which must be of the given pclass.
 * This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.
 *
 * @param ptype type of value present on stack
 * @param pclass type of value required on stack
 * @param arg compile-time representation of value on stack (Node, constant) or null if none
 */
private void emitImplicitConversion(BasicType ptype, Class<?> pclass, Object arg) {
    assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
    if (pclass == ptype.basicTypeClass() && ptype != L_TYPE)
        return;   // nothing to do
    switch (ptype) {
        case L_TYPE:
            if (VerifyType.isNullConversion(Object.class, pclass, false)) {
                if (PROFILE_LEVEL > 0)
                    emitReferenceCast(Object.class, arg);
                return;
            }
            emitReferenceCast(pclass, arg);
            return;
        case I_TYPE:
            if (!VerifyType.isNullConversion(int.class, pclass, false))
                emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
            return;
    }
    throw newInternalError("bad implicit conversion: tc="+ptype+": "+pclass);
}

Example #15

Source File: MethodType.java From Java8CN with Apache License 2.0

6 votes

/** True if the new parameters can be viewed (w/o casting) under the old parameter types. */
/*non-public*/
boolean parametersAreViewableAs(MethodType newType, boolean keepInterfaces) {
    if (form == newType.form && form.erasedType == this)
        return true;  // my reference parameters are all Object
    if (ptypes == newType.ptypes)
        return true;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i), keepInterfaces))
            return false;
    }
    return true;
}

Example #16

Source File: InvokerBytecodeGenerator.java From hottub with GNU General Public License v2.0

6 votes

/**
 * Emit an implicit conversion for an argument which must be of the given pclass.
 * This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.
 *
 * @param ptype type of value present on stack
 * @param pclass type of value required on stack
 * @param arg compile-time representation of value on stack (Node, constant) or null if none
 */
private void emitImplicitConversion(BasicType ptype, Class<?> pclass, Object arg) {
    assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
    if (pclass == ptype.basicTypeClass() && ptype != L_TYPE)
        return;   // nothing to do
    switch (ptype) {
        case L_TYPE:
            if (VerifyType.isNullConversion(Object.class, pclass, false)) {
                if (PROFILE_LEVEL > 0)
                    emitReferenceCast(Object.class, arg);
                return;
            }
            emitReferenceCast(pclass, arg);
            return;
        case I_TYPE:
            if (!VerifyType.isNullConversion(int.class, pclass, false))
                emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
            return;
    }
    throw newInternalError("bad implicit conversion: tc="+ptype+": "+pclass);
}

Example #17

Source File: InvokerBytecodeGenerator.java From openjdk-jdk8u with GNU General Public License v2.0

6 votes

/**
 * Emit an implicit conversion for an argument which must be of the given pclass.
 * This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.
 *
 * @param ptype type of value present on stack
 * @param pclass type of value required on stack
 * @param arg compile-time representation of value on stack (Node, constant) or null if none
 */
private void emitImplicitConversion(BasicType ptype, Class<?> pclass, Object arg) {
    assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
    if (pclass == ptype.basicTypeClass() && ptype != L_TYPE)
        return;   // nothing to do
    switch (ptype) {
        case L_TYPE:
            if (VerifyType.isNullConversion(Object.class, pclass, false)) {
                if (PROFILE_LEVEL > 0)
                    emitReferenceCast(Object.class, arg);
                return;
            }
            emitReferenceCast(pclass, arg);
            return;
        case I_TYPE:
            if (!VerifyType.isNullConversion(int.class, pclass, false))
                emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
            return;
    }
    throw newInternalError("bad implicit conversion: tc="+ptype+": "+pclass);
}

Example #18

Source File: InvokerBytecodeGenerator.java From jdk8u_jdk with GNU General Public License v2.0

6 votes

/**
 * Emit an implicit conversion for an argument which must be of the given pclass.
 * This is usually a no-op, except when pclass is a subword type or a reference other than Object or an interface.
 *
 * @param ptype type of value present on stack
 * @param pclass type of value required on stack
 * @param arg compile-time representation of value on stack (Node, constant) or null if none
 */
private void emitImplicitConversion(BasicType ptype, Class<?> pclass, Object arg) {
    assert(basicType(pclass) == ptype);  // boxing/unboxing handled by caller
    if (pclass == ptype.basicTypeClass() && ptype != L_TYPE)
        return;   // nothing to do
    switch (ptype) {
        case L_TYPE:
            if (VerifyType.isNullConversion(Object.class, pclass, false)) {
                if (PROFILE_LEVEL > 0)
                    emitReferenceCast(Object.class, arg);
                return;
            }
            emitReferenceCast(pclass, arg);
            return;
        case I_TYPE:
            if (!VerifyType.isNullConversion(int.class, pclass, false))
                emitPrimCast(ptype.basicTypeWrapper(), Wrapper.forPrimitiveType(pclass));
            return;
    }
    throw newInternalError("bad implicit conversion: tc="+ptype+": "+pclass);
}

Example #19

Source File: MethodHandleImpl.java From jdk8u_jdk with GNU General Public License v2.0

5 votes

static Object[] computeValueConversions(MethodType srcType, MethodType dstType,
                                        boolean strict, boolean monobox) {
    final int INARG_COUNT = srcType.parameterCount();
    Object[] convSpecs = new Object[INARG_COUNT+1];
    for (int i = 0; i <= INARG_COUNT; i++) {
        boolean isRet = (i == INARG_COUNT);
        Class<?> src = isRet ? dstType.returnType() : srcType.parameterType(i);
        Class<?> dst = isRet ? srcType.returnType() : dstType.parameterType(i);
        if (!VerifyType.isNullConversion(src, dst, /*keepInterfaces=*/ strict)) {
            convSpecs[i] = valueConversion(src, dst, strict, monobox);
        }
    }
    return convSpecs;
}

Example #20

Source File: MethodType.java From dragonwell8_jdk with GNU General Public License v2.0

5 votes

/** True if the old return type can always be viewed (w/o casting) under new return type,
 *  and the new parameters can be viewed (w/o casting) under the old parameter types.
 */
/*non-public*/
boolean isViewableAs(MethodType newType, boolean keepInterfaces) {
    if (!VerifyType.isNullConversion(returnType(), newType.returnType(), keepInterfaces))
        return false;
    return parametersAreViewableAs(newType, keepInterfaces);
}

Example #21

Source File: MethodHandleImpl.java From jdk8u-jdk with GNU General Public License v2.0

5 votes

static Object[] computeValueConversions(MethodType srcType, MethodType dstType,
                                        boolean strict, boolean monobox) {
    final int INARG_COUNT = srcType.parameterCount();
    Object[] convSpecs = new Object[INARG_COUNT+1];
    for (int i = 0; i <= INARG_COUNT; i++) {
        boolean isRet = (i == INARG_COUNT);
        Class<?> src = isRet ? dstType.returnType() : srcType.parameterType(i);
        Class<?> dst = isRet ? srcType.returnType() : dstType.parameterType(i);
        if (!VerifyType.isNullConversion(src, dst, /*keepInterfaces=*/ strict)) {
            convSpecs[i] = valueConversion(src, dst, strict, monobox);
        }
    }
    return convSpecs;
}

Example #22

Source File: MethodHandleImpl.java From jdk8u-dev-jdk with GNU General Public License v2.0

5 votes

static Object[] computeValueConversions(MethodType srcType, MethodType dstType,
                                        boolean strict, boolean monobox) {
    final int INARG_COUNT = srcType.parameterCount();
    Object[] convSpecs = new Object[INARG_COUNT+1];
    for (int i = 0; i <= INARG_COUNT; i++) {
        boolean isRet = (i == INARG_COUNT);
        Class<?> src = isRet ? dstType.returnType() : srcType.parameterType(i);
        Class<?> dst = isRet ? srcType.returnType() : dstType.parameterType(i);
        if (!VerifyType.isNullConversion(src, dst, /*keepInterfaces=*/ strict)) {
            convSpecs[i] = valueConversion(src, dst, strict, monobox);
        }
    }
    return convSpecs;
}

Example #23

Source File: MethodHandleImpl.java From jdk8u-jdk with GNU General Public License v2.0

5 votes

static Object[] computeValueConversions(MethodType srcType, MethodType dstType,
                                        boolean strict, boolean monobox) {
    final int INARG_COUNT = srcType.parameterCount();
    Object[] convSpecs = new Object[INARG_COUNT+1];
    for (int i = 0; i <= INARG_COUNT; i++) {
        boolean isRet = (i == INARG_COUNT);
        Class<?> src = isRet ? dstType.returnType() : srcType.parameterType(i);
        Class<?> dst = isRet ? srcType.returnType() : dstType.parameterType(i);
        if (!VerifyType.isNullConversion(src, dst, /*keepInterfaces=*/ strict)) {
            convSpecs[i] = valueConversion(src, dst, strict, monobox);
        }
    }
    return convSpecs;
}

Example #24

Source File: MethodType.java From jdk8u-jdk with GNU General Public License v2.0

5 votes

/** True if the old return type can always be viewed (w/o casting) under new return type,
 *  and the new parameters can be viewed (w/o casting) under the old parameter types.
 */
/*non-public*/
boolean isViewableAs(MethodType newType, boolean keepInterfaces) {
    if (!VerifyType.isNullConversion(returnType(), newType.returnType(), keepInterfaces))
        return false;
    return parametersAreViewableAs(newType, keepInterfaces);
}

Example #25

Source File: MethodHandleImpl.java From openjdk-jdk9 with GNU General Public License v2.0

5 votes

static Object[] computeValueConversions(MethodType srcType, MethodType dstType,
                                        boolean strict, boolean monobox) {
    final int INARG_COUNT = srcType.parameterCount();
    Object[] convSpecs = new Object[INARG_COUNT+1];
    for (int i = 0; i <= INARG_COUNT; i++) {
        boolean isRet = (i == INARG_COUNT);
        Class<?> src = isRet ? dstType.returnType() : srcType.parameterType(i);
        Class<?> dst = isRet ? srcType.returnType() : dstType.parameterType(i);
        if (!VerifyType.isNullConversion(src, dst, /*keepInterfaces=*/ strict)) {
            convSpecs[i] = valueConversion(src, dst, strict, monobox);
        }
    }
    return convSpecs;
}

Example #26

Source File: MethodType.java From openjdk-8-source with GNU General Public License v2.0

5 votes

boolean isViewableAs(MethodType newType) {
    if (!VerifyType.isNullConversion(returnType(), newType.returnType()))
        return false;
    int argc = parameterCount();
    if (argc != newType.parameterCount())
        return false;
    for (int i = 0; i < argc; i++) {
        if (!VerifyType.isNullConversion(newType.parameterType(i), parameterType(i)))
            return false;
    }
    return true;
}

Example #27

Source File: MethodHandleImpl.java From dragonwell8_jdk with GNU General Public License v2.0

5 votes

static Object[] computeValueConversions(MethodType srcType, MethodType dstType,
                                        boolean strict, boolean monobox) {
    final int INARG_COUNT = srcType.parameterCount();
    Object[] convSpecs = new Object[INARG_COUNT+1];
    for (int i = 0; i <= INARG_COUNT; i++) {
        boolean isRet = (i == INARG_COUNT);
        Class<?> src = isRet ? dstType.returnType() : srcType.parameterType(i);
        Class<?> dst = isRet ? srcType.returnType() : dstType.parameterType(i);
        if (!VerifyType.isNullConversion(src, dst, /*keepInterfaces=*/ strict)) {
            convSpecs[i] = valueConversion(src, dst, strict, monobox);
        }
    }
    return convSpecs;
}

Example #28

Source File: DirectMethodHandle.java From jdk1.8-source-analysis with Apache License 2.0

5 votes

private static int ftypeKind(Class<?> ftype) {
    if (ftype.isPrimitive())
        return Wrapper.forPrimitiveType(ftype).ordinal();
    else if (VerifyType.isNullReferenceConversion(Object.class, ftype))
        return FT_UNCHECKED_REF;
    else
        return FT_CHECKED_REF;
}

Example #29

Source File: DirectMethodHandle.java From openjdk-jdk9 with GNU General Public License v2.0

5 votes

static int ftypeKind(Class<?> ftype) {
    if (ftype.isPrimitive())
        return Wrapper.forPrimitiveType(ftype).ordinal();
    else if (VerifyType.isNullReferenceConversion(Object.class, ftype))
        return FT_UNCHECKED_REF;
    else
        return FT_CHECKED_REF;
}

Example #30

Source File: DirectMethodHandle.java From Bytecoder with Apache License 2.0

5 votes

static int ftypeKind(Class<?> ftype) {
    if (ftype.isPrimitive())
        return Wrapper.forPrimitiveType(ftype).ordinal();
    else if (VerifyType.isNullReferenceConversion(Object.class, ftype))
        return FT_UNCHECKED_REF;
    else
        return FT_CHECKED_REF;
}