public Assembler sub(Type t) { int opcode = -1; switch (t.getSort()) { case Type.SHORT: case Type.BYTE: case Type.INT: { opcode = ISUB; break; } case Type.LONG: { opcode = LSUB; break; } case Type.FLOAT: { opcode = FSUB; break; } case Type.DOUBLE: { opcode = DSUB; break; } } if (opcode != -1) { mv.visitInsn(opcode); } return this; }
/** * Checks the type compatibility<br> * Two types are compatible when and only when: * * <ol> * <li>They are exactly the same * <li>The left parameter is {@linkplain Object} or {@linkplain AnyType} and the right parameter * is either {@linkplain Object} or an array * <li>The left parameter is assignable from the right one (is a superclass of the right one) * </ol> * * @param left The left type parameter * @param right The right type parameter * @return Returns true if a value of the left {@linkplain Type} can hold the value of the right * {@linkplain Type} */ public static boolean isCompatible(Type left, Type right) { if (left.equals(right)) { return true; } else if (isArray(left)) { return false; } else if (isObjectOrAnyType(left)) { int sort2 = right.getSort(); return (sort2 == Type.OBJECT || sort2 == Type.ARRAY); } else if (isPrimitive(left)) { // a primitive type requires strict equality return left.equals(right); } else { ClassLoader cl = Thread.currentThread().getContextClassLoader(); if (cl == null) { cl = ClassLoader.getSystemClassLoader(); } // those classes should already have been loaded at this point Class clzLeft, clzRight; try { clzLeft = cl.loadClass(left.getClassName()); } catch (Throwable e) { clzLeft = Object.class; } // anything is assignable to Object if (clzLeft == Object.class) { return true; } try { clzRight = cl.loadClass(right.getClassName()); } catch (Throwable e) { clzRight = Object.class; } return (clzLeft.isAssignableFrom(clzRight)); } }
public static boolean isArray(Type t) { return t.getSort() == Type.ARRAY; }