Java Type.getSort方法代碼示例

import org.objectweb.asm.Type; //導入方法依賴的package包/類
private Type mapType(Type t) {
    switch (t.getSort()) {
    case Type.ARRAY:
        String s = mapDesc(t.getElementType().getDescriptor());
        for (int i = 0; i < t.getDimensions(); ++i) {
            s = '[' + s;
        }
        return Type.getType(s);
    case Type.OBJECT:
        s = map(t.getInternalName());
        return s != null ? Type.getObjectType(s) : t;
    case Type.METHOD:
        return Type.getMethodType(mapMethodDesc(t.getDescriptor()));
    }
    return t;
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
/**
 * Generates the instructions to box the top stack value. This value is
 * replaced by its boxed equivalent on top of the stack.
 * 
 * @param type
 *            the type of the top stack value.
 */
public void box(final Type type) {
    if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
        return;
    }
    if (type == Type.VOID_TYPE) {
        push((String) null);
    } else {
        Type boxed = getBoxedType(type);
        newInstance(boxed);
        if (type.getSize() == 2) {
            // Pp -> Ppo -> oPpo -> ooPpo -> ooPp -> o
            dupX2();
            dupX2();
            pop();
        } else {
            // p -> po -> opo -> oop -> o
            dupX1();
            swap();
        }
        invokeConstructor(boxed, new Method("<init>", Type.VOID_TYPE,
                new Type[] { type }));
    }
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
public void validate(String value) {
    if (value.startsWith("$this") && method.equals("<init>")) {
        throwLabelInvalidException(value, "Cannot use $this in Constructor");
    }

    if (value.startsWith("$")) {
        if (!value.matches("\\$([0-9]+|this)([a-zA-Z.]+)*")) {
            throwLabelInvalidException(value, "Must match pattern \\\\$([0-9]+|this)([a-zA-Z.]+)* or start with $this");
        }

        if (!value.startsWith("$this")) {

            int index = LabelUtil.getLabelVarIndex(value);

            if (index >= argTypes.length) {
                throwLabelInvalidException(value, "It only has " + argTypes.length + " params");
            }

            Type argType = argTypes[index];
            if (argType.getSort() == Type.ARRAY) {
                throwLabelInvalidException(value, "ARRAY type is not allowed");
            }
        }
    }
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
private static Type getBoxedType(final Type type) {
    switch (type.getSort()) {
    case Type.BYTE:
        return BYTE_TYPE;
    case Type.BOOLEAN:
        return BOOLEAN_TYPE;
    case Type.SHORT:
        return SHORT_TYPE;
    case Type.CHAR:
        return CHARACTER_TYPE;
    case Type.INT:
        return INTEGER_TYPE;
    case Type.FLOAT:
        return FLOAT_TYPE;
    case Type.LONG:
        return LONG_TYPE;
    case Type.DOUBLE:
        return DOUBLE_TYPE;
    }
    return type;
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
private static MoveType moveType(Type type) {
  switch (type.getSort()) {
    case Type.ARRAY:
    case Type.OBJECT:
      return MoveType.OBJECT;
    case Type.BOOLEAN:
    case Type.BYTE:
    case Type.SHORT:
    case Type.CHAR:
    case Type.INT:
    case Type.FLOAT:
      return MoveType.SINGLE;
    case Type.LONG:
    case Type.DOUBLE:
      return MoveType.WIDE;
    case Type.VOID:
      // Illegal. Throws in fallthrough.
    default:
      throw new Unreachable("Invalid type in moveType: " + type);
  }
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
private static ConstType constType(Type type) {
  switch (type.getSort()) {
    case Type.ARRAY:
    case Type.OBJECT:
      return ConstType.OBJECT;
    case Type.BOOLEAN:
    case Type.BYTE:
    case Type.SHORT:
    case Type.CHAR:
    case Type.INT:
      return ConstType.INT;
    case Type.FLOAT:
      return ConstType.FLOAT;
    case Type.LONG:
      return ConstType.LONG;
    case Type.DOUBLE:
      return ConstType.DOUBLE;
    case Type.VOID:
      // Illegal. Throws in fallthrough.
    default:
      throw new Unreachable("Invalid type in constType: " + type);
  }
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
@Override
public BasicValue newValue(final Type type) {
    if (type == null) {
        return BasicValue.UNINITIALIZED_VALUE;
    }
    switch (type.getSort()) {
    case Type.VOID:
        return null;
    case Type.BOOLEAN:
    case Type.CHAR:
    case Type.BYTE:
    case Type.SHORT:
    case Type.INT:
        return BasicValue.INT_VALUE;
    case Type.FLOAT:
        return BasicValue.FLOAT_VALUE;
    case Type.LONG:
        return BasicValue.LONG_VALUE;
    case Type.DOUBLE:
        return BasicValue.DOUBLE_VALUE;
    case Type.ARRAY:
    case Type.OBJECT:
        return BasicValue.REFERENCE_VALUE;
    default:
        throw new Error("Internal error");
    }
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
private static String getShortyDescriptor(Type type) {
  switch (type.getSort()) {
    case Type.METHOD:
      throw new InternalCompilerError("Cannot produce a shorty decriptor for methods");
    case Type.ARRAY:
    case Type.OBJECT:
      return "L";
    default:
      return type.getDescriptor();
  }
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
private boolean isFieldInlineable(int access, String desc) {
	if ((access & OPCODE_FIELD_INLINEABLE) != 0) {
		final Type type = Type.getType(desc);
		return type.getSort() != Type.OBJECT || "java.lang.String".equals(type.getClassName());
	}
	return false;
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
/**
 * Creates a new local variable of the given type.
 * 
 * @param type
 *            the type of the local variable to be created.
 * @return the identifier of the newly created local variable.
 */
public int newLocal(final Type type) {
    Object t;
    switch (type.getSort()) {
    case Type.BOOLEAN:
    case Type.CHAR:
    case Type.BYTE:
    case Type.SHORT:
    case Type.INT:
        t = Opcodes.INTEGER;
        break;
    case Type.FLOAT:
        t = Opcodes.FLOAT;
        break;
    case Type.LONG:
        t = Opcodes.LONG;
        break;
    case Type.DOUBLE:
        t = Opcodes.DOUBLE;
        break;
    case Type.ARRAY:
        t = type.getDescriptor();
        break;
    // case Type.OBJECT:
    default:
        t = type.getInternalName();
        break;
    }
    int local = newLocalMapping(type);
    setLocalType(local, type);
    setFrameLocal(local, t);
    return local;
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
protected boolean isAssignableFrom(final Type t, final Type u) {
    if (t.equals(u)) {
        return true;
    }
    if (currentClass != null && t.equals(currentClass)) {
        if (getSuperClass(u) == null) {
            return false;
        } else {
            if (isInterface) {
                return u.getSort() == Type.OBJECT
                        || u.getSort() == Type.ARRAY;
            }
            return isAssignableFrom(t, getSuperClass(u));
        }
    }
    if (currentClass != null && u.equals(currentClass)) {
        if (isAssignableFrom(t, currentSuperClass)) {
            return true;
        }
        if (currentClassInterfaces != null) {
            for (int i = 0; i < currentClassInterfaces.size(); ++i) {
                Type v = currentClassInterfaces.get(i);
                if (isAssignableFrom(t, v)) {
                    return true;
                }
            }
        }
        return false;
    }
    Class<?> tc = getClass(t);
    if (tc.isInterface()) {
        tc = Object.class;
    }
    return tc.isAssignableFrom(getClass(u));
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
@Override
protected BasicValue getElementValue(final BasicValue objectArrayValue)
        throws AnalyzerException {
    Type arrayType = objectArrayValue.getType();
    if (arrayType != null) {
        if (arrayType.getSort() == Type.ARRAY) {
            return newValue(Type.getType(arrayType.getDescriptor()
                    .substring(1)));
        } else if ("Lnull;".equals(arrayType.getDescriptor())) {
            return objectArrayValue;
        }
    }
    throw new Error("Internal error");
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
private DexValue decodeBootstrapArgument(Object value) {
  if (value instanceof Integer) {
    return DexValue.DexValueInt.create((Integer) value);
  } else if (value instanceof Long) {
    return DexValue.DexValueLong.create((Long) value);
  } else if (value instanceof Float) {
    return DexValue.DexValueFloat.create((Float) value);
  } else if (value instanceof Double) {
    return DexValue.DexValueDouble.create((Double) value);
  } else if (value instanceof String) {
    return new DexValue.DexValueString(application.getString((String) value));

  } else if (value instanceof Type) {
    Type type = (Type) value;
    switch (type.getSort()) {
      case Type.OBJECT:
        return new DexValue.DexValueType(
            application.getTypeFromDescriptor(((Type) value).getDescriptor()));
      case Type.METHOD:
        return new DexValue.DexValueMethodType(
            application.getProto(((Type) value).getDescriptor()));
    }
    throw new Unreachable("Type sort is not supported: " + type.getSort());

  } else if (value instanceof Handle) {
    return new DexValue.DexValueMethodHandle(getMethodHandle(application, (Handle) value));
  } else {
    throw new Unreachable(
        "Unsupported bootstrap static argument of type " + value.getClass().getSimpleName());
  }
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
private static Collection<Reference<? extends Item>> processReferenceAnnotation(Item item, AnnotationNode node, Class<?> annotClass) throws ConstraintException {
    if (!annotClass.isAnnotation())
        throw new IllegalArgumentException("annotClass must be an annotation type");
    if (!("L" + annotClass.getName().replace('.', '/') + ";").equals(node.desc))
        throw new IllegalArgumentException("annot class mismatch");
    Map<Object, Object> map = processPairs(node.values);
    Object value = map.get("value");
    if (!(value instanceof List))
        throw new ConstraintException("value not given");
    Object weakBoxed = map.get("weakBoxed");
    if (weakBoxed == null) {
        try {
            weakBoxed = annotClass.getDeclaredMethod("weak").getDefaultValue();
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }
    if (!(weakBoxed instanceof Boolean))
        throw new ConstraintException("Invalid or null weak property type");
    boolean isStrong = !(boolean) weakBoxed;
    Collection<Reference<? extends Item>> refs = new ArrayList<>();
    for (Object ref : (List<?>) value) {
        String id = null;
        if (ref instanceof String)
            id = ((String) ref).replace(".", "/");
        else if (ref instanceof Type) {
            Type typ = (Type) ref;
            if (typ.getSort() == Type.OBJECT) {
                id = typ.getInternalName();
                if (id == null) throw new NullPointerException();
            }
        }
        if (id == null)
            throw new ConstraintException("Invalid type specified in value: " + ref + " (" + ref.getClass() + ")");
        refs.add(new ReferenceProxy<>(item, id, isStrong)); // TODO use legitimate one
    }
    return refs;
}
 

import org.objectweb.asm.Type; //導入方法依賴的package包/類
/**
 * Generates the instructions to jump to a label based on the comparison of
 * the top two stack values.
 * 
 * @param type
 *            the type of the top two stack values.
 * @param mode
 *            how these values must be compared. One of EQ, NE, LT, GE, GT,
 *            LE.
 * @param label
 *            where to jump if the comparison result is <tt>true</tt>.
 */
public void ifCmp(final Type type, final int mode, final Label label) {
    switch (type.getSort()) {
    case Type.LONG:
        mv.visitInsn(Opcodes.LCMP);
        break;
    case Type.DOUBLE:
        mv.visitInsn(mode == GE || mode == GT ? Opcodes.DCMPL
                : Opcodes.DCMPG);
        break;
    case Type.FLOAT:
        mv.visitInsn(mode == GE || mode == GT ? Opcodes.FCMPL
                : Opcodes.FCMPG);
        break;
    case Type.ARRAY:
    case Type.OBJECT:
        switch (mode) {
        case EQ:
            mv.visitJumpInsn(Opcodes.IF_ACMPEQ, label);
            return;
        case NE:
            mv.visitJumpInsn(Opcodes.IF_ACMPNE, label);
            return;
        }
        throw new IllegalArgumentException("Bad comparison for type "
                + type);
    default:
        int intOp = -1;
        switch (mode) {
        case EQ:
            intOp = Opcodes.IF_ICMPEQ;
            break;
        case NE:
            intOp = Opcodes.IF_ICMPNE;
            break;
        case GE:
            intOp = Opcodes.IF_ICMPGE;
            break;
        case LT:
            intOp = Opcodes.IF_ICMPLT;
            break;
        case LE:
            intOp = Opcodes.IF_ICMPLE;
            break;
        case GT:
            intOp = Opcodes.IF_ICMPGT;
            break;
        }
        mv.visitJumpInsn(intOp, label);
        return;
    }
    mv.visitJumpInsn(mode, label);
}