Java Code Examples for sun.invoke.util.Wrapper#basicTypeChar()

public static void spreadArray(short[] array,
                               StackFrameWriter writer, MethodType type,
                               int numArgs, int offset) {
    final Class<?>[] ptypes = type.ptypes();
    for (int i = 0; i < numArgs; ++i) {
        Class<?> argumentType = ptypes[i + offset];
        short s = array[i];
        switch (Wrapper.basicTypeChar(argumentType)) {
            case 'L': { writer.putNextReference(s, argumentType); break; }
            case 'I': { writer.putNextInt(s); break; }
            case 'J': { writer.putNextLong(s); break; }
            case 'S': { writer.putNextShort(s); break; }
            case 'F': { writer.putNextFloat(s); break; }
            case 'D': { writer.putNextDouble(s); break; }
            default : { throw new AssertionError(); }
        }
    }
}
 

/**
 * Emits an actual return instruction conforming to the given return type.
 */
private void emitReturnInsn(Class<?> type) {
    int opcode;
    switch (Wrapper.basicTypeChar(type)) {
    case 'I':  opcode = Opcodes.IRETURN;  break;
    case 'J':  opcode = Opcodes.LRETURN;  break;
    case 'F':  opcode = Opcodes.FRETURN;  break;
    case 'D':  opcode = Opcodes.DRETURN;  break;
    case 'L':  opcode = Opcodes.ARETURN;  break;
    case 'V':  opcode = Opcodes.RETURN;   break;
    default:
        throw new InternalError("unknown return type: " + type);
    }
    mv.visitInsn(opcode);
}
 

/**
 * Emit an unboxing call (plus preceding checkcast).
 *
 * @param wrapper wrapper type class to unbox.
 */
private void emitUnboxing(Wrapper wrapper) {
    String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
    String name  = wrapper.primitiveSimpleName() + "Value";
    String desc  = "()" + wrapper.basicTypeChar();
    emitReferenceCast(wrapper.wrapperType(), null);
    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false);
}
 

/**
 * Emit a boxing call.
 *
 * @param wrapper primitive type class to box.
 */
private void emitBoxing(Wrapper wrapper) {
    String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
    String name  = "valueOf";
    String desc  = "(" + wrapper.basicTypeChar() + ")L" + owner + ";";
    mv.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false);
}
 

/**
 * Emit a boxing call.
 *
 * @param wrapper primitive type class to box.
 */
private void emitBoxing(Wrapper wrapper) {
    String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
    String name  = "valueOf";
    String desc  = "(" + wrapper.basicTypeChar() + ")L" + owner + ";";
    mv.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false);
}
 

/**
 * Emit an unboxing call (plus preceding checkcast).
 *
 * @param wrapper wrapper type class to unbox.
 */
private void emitUnboxing(Wrapper wrapper) {
    String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
    String name  = wrapper.primitiveSimpleName() + "Value";
    String desc  = "()" + wrapper.basicTypeChar();
    emitReferenceCast(wrapper.wrapperType(), null);
    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false);
}
 

/**
 * Emit a boxing call.
 *
 * @param wrapper primitive type class to box.
 */
private void emitBoxing(Wrapper wrapper) {
    String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
    String name  = "valueOf";
    String desc  = "(" + wrapper.basicTypeChar() + ")L" + owner + ";";
    mv.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false);
}
 

private static Object shortArray(StackFrameReader reader, Class<?> ptypes[],
                                int offset, int length) {
    short[] arityArray = new short[length];
    for (int i = 0; i < length; ++i) {
        Class<?> argumentType = ptypes[i + offset];
        switch (Wrapper.basicTypeChar(argumentType)) {
            case 'S': { arityArray[i] = reader.nextShort(); break; }
            case 'B': { arityArray[i] = reader.nextByte(); break; }
            default: { arityArray[i] = (Short) reader.nextReference(argumentType); break; }
        }
    }
    return arityArray;
}
 

/**
 * Emit a boxing call.
 *
 * @param wrapper primitive type class to box.
 */
private void emitBoxing(Wrapper wrapper) {
    String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
    String name  = "valueOf";
    String desc  = "(" + wrapper.basicTypeChar() + ")L" + owner + ";";
    mv.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false);
}
 

public static void spreadArray(boolean[] array,
                               StackFrameWriter writer, MethodType type,
                               int numArgs, int offset) {
    final Class<?>[] ptypes = type.ptypes();
    for (int i = 0; i < numArgs; ++i) {
        Class<?> argumentType = ptypes[i + offset];
        boolean z = array[i];
        switch (Wrapper.basicTypeChar(argumentType)) {
            case 'L': { writer.putNextReference(z, argumentType); break; }
            case 'Z': { writer.putNextBoolean(z); break; }
            default : { throw new AssertionError(); }
        }
    }
}
 

/**
 * Emit a boxing call.
 *
 * @param wrapper primitive type class to box.
 */
private void emitBoxing(Wrapper wrapper) {
    String owner = "java/lang/" + wrapper.wrapperType().getSimpleName();
    String name  = "valueOf";
    String desc  = "(" + wrapper.basicTypeChar() + ")L" + owner + ";";
    mv.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false);
}
 

static String name(Class<?> arrayClass, boolean isSetter) {
    Class<?> elemClass = arrayClass.getComponentType();
    if (elemClass == null)  throw newIllegalArgumentException("not an array", arrayClass);
    return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(elemClass);
}
 

public static char basicType(Class<?> type) {
    char c = Wrapper.basicTypeChar(type);
    if ("ZBSC".indexOf(c) >= 0)  c = 'I';
    assert("LIJFDV".indexOf(c) >= 0);
    return c;
}
 

private static String boxingDescriptor(Wrapper w) {
    return "(" + w.basicTypeChar() + ")L" + wrapperName(w) + ";";
}
 

static BasicType basicType(Wrapper type) {
    char c = type.basicTypeChar();
    return basicType(c);
}
 

static String name(Class<?> arrayClass, boolean isSetter) {
    Class<?> elemClass = arrayClass.getComponentType();
    if (elemClass == null)  throw newIllegalArgumentException("not an array", arrayClass);
    return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(elemClass);
}
 

/**
 * Emits a return statement from a LF invoker. If required, the result type is cast to the correct return type.
 */
private void emitReturn() {
    // return statement
    if (lambdaForm.result == -1) {
        // void
        mv.visitInsn(Opcodes.RETURN);
    } else {
        LambdaForm.Name rn = lambdaForm.names[lambdaForm.result];
        char rtype = Wrapper.basicTypeChar(invokerType.returnType());

        // put return value on the stack if it is not already there
        if (lambdaForm.result != lambdaForm.names.length - 1) {
            emitLoadInsn(rn.type, lambdaForm.result);
        }

        // potentially generate cast
        // rtype is the return type of the invoker - generated code must conform to this
        // rn.type is the type of the result Name in the LF
        if (rtype != rn.type) {
            // need cast
            if (rtype == 'L') {
                // possibly cast the primitive to the correct type for boxing
                char boxedType = Wrapper.forWrapperType(invokerType.returnType()).basicTypeChar();
                if (boxedType != rn.type) {
                    emitPrimCast(rn.type, boxedType);
                }
                // cast primitive to reference ("boxing")
                emitBoxing(invokerType.returnType());
            } else {
                // to-primitive cast
                if (rn.type != 'L') {
                    // prim-to-prim cast
                    emitPrimCast(rn.type, rtype);
                } else {
                    // ref-to-prim cast ("unboxing")
                    throw new InternalError("no ref-to-prim (unboxing) casts supported right now");
                }
            }
        }

        // generate actual return statement
        emitReturnInsn(invokerType.returnType());
    }
}
 

static String name(Class<?> arrayClass, boolean isSetter) {
    Class<?> elemClass = arrayClass.getComponentType();
    if (elemClass == null)  throw newIllegalArgumentException("not an array", arrayClass);
    return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(elemClass);
}
 

private static String unboxingDescriptor(Wrapper w) {
    return "()" + w.basicTypeChar();
}
 

static String name(Class<?> arrayClass, boolean isSetter) {
    Class<?> elemClass = arrayClass.getComponentType();
    if (elemClass == null)  throw newIllegalArgumentException("not an array", arrayClass);
    return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(elemClass);
}