Java GeneratorAdapter.unbox方法代码示例

import org.objectweb.asm.commons.GeneratorAdapter; //导入方法依赖的package包/类
/**
 * Generates unboxing bytecode for the passed type. An {@link Object} is expected to be on the
 * stack when these bytecodes are inserted.
 *
 * ASM takes a short cut when dealing with short/byte types and convert them into int rather
 * than short/byte types. This is not an issue on the jvm nor Android's ART but it is an issue
 * on Dalvik.
 *
 * @param mv the {@link GeneratorAdapter} generating a method implementation.
 * @param type the expected un-boxed type.
 */
public static void unbox(GeneratorAdapter mv, Type type) {
    if (type.equals(Type.SHORT_TYPE)) {
        mv.checkCast(NUMBER_TYPE);
        mv.invokeVirtual(NUMBER_TYPE, SHORT_VALUE);
    } else if (type.equals(Type.BYTE_TYPE)) {
        mv.checkCast(NUMBER_TYPE);
        mv.invokeVirtual(NUMBER_TYPE, BYTE_VALUE);
    } else {
        mv.unbox(type);
    }
}
 

import org.objectweb.asm.commons.GeneratorAdapter; //导入方法依赖的package包/类
@Contract("null, null, null, !null -> fail")
private static void loadArguments(GeneratorAdapter ga, Type[] interfaceTypes, Type[] targetTypes, boolean isTargetPublic) {
    Ensure.ensureCondition(interfaceTypes.length == targetTypes.length,
            "Interface and target parameter count don't match!");
    /* Iterate through all types */
    for(int i = 0; i < interfaceTypes.length; i++) {
        Type interfaceType = interfaceTypes[i];
        Type targetType = targetTypes[i];

        ga.loadArg(i);

        /* Do not do boxing/unboxing if MethodHandle.invoke is used, it handles them on its own */
        if(!isTargetPublic) continue;

        if(isPrimitive(interfaceType)) {
            if(!isPrimitive(targetType)) {
                ga.box(targetType);
            }
        } else {
            if(isPrimitive(targetType)) {
                ga.unbox(targetType);
            } else {
                if(interfaceType.equals(OBJECT)) {
                    ga.checkCast(targetType);
                    ga.cast(interfaceType, targetType);
                }
            }
        }
    }
}
 

import org.objectweb.asm.commons.GeneratorAdapter; //导入方法依赖的package包/类
@Contract("null, null, null -> fail")
private static void handleReturn(GeneratorAdapter ga, Method interfaceMethod, Type targetReturnType) {
    Type returnType = Type.getReturnType(interfaceMethod);

    if(isPrimitive(returnType)) {
        if(!isPrimitive(targetReturnType)) {
            ga.unbox(targetReturnType);
        }
    } else {
        if(isPrimitive(targetReturnType)) {
            ga.box(targetReturnType);
        }
    }
}
 

import org.objectweb.asm.commons.GeneratorAdapter; //导入方法依赖的package包/类
static void emitBody(ObjExpr objx, GeneratorAdapter gen, Class retClass, Expr body) {
		MaybePrimitiveExpr be = (MaybePrimitiveExpr) body;
		if(Util.isPrimitive(retClass) && be.canEmitPrimitive())
			{
			Class bc = maybePrimitiveType(be);
			if(bc == retClass)
				be.emitUnboxed(C.RETURN, objx, gen);
			else if(retClass == long.class && bc == int.class)
				{
				be.emitUnboxed(C.RETURN, objx, gen);
				gen.visitInsn(I2L);
				}
			else if(retClass == double.class && bc == float.class)
				{
				be.emitUnboxed(C.RETURN, objx, gen);
				gen.visitInsn(F2D);
				}
			else if(retClass == int.class && bc == long.class)
				{
				be.emitUnboxed(C.RETURN, objx, gen);
				gen.invokeStatic(RT_TYPE, Method.getMethod("int intCast(long)"));
				}
			else if(retClass == float.class && bc == double.class)
				{
				be.emitUnboxed(C.RETURN, objx, gen);
				gen.visitInsn(D2F);
				}
			else
				throw new IllegalArgumentException("Mismatched primitive return, expected: "
				                                   + retClass + ", had: " + be.getJavaClass());
			}
		else
			{
			body.emit(C.RETURN, objx, gen);
			if(retClass == void.class)
				{
				gen.pop();
				}
			else
				gen.unbox(Type.getType(retClass));
			}
}