import com.android.dx.rop.cst.CstLong; //导入依赖的package包/类
/**
 * Constructs an instance.
 *
 * @param constantValue {@code non-null;} the constant value, which must
 * be an instance of one of: {@code CstString},
 * {@code CstInteger}, {@code CstLong},
 * {@code CstFloat}, or {@code CstDouble}
 */
public AttConstantValue(TypedConstant constantValue) {
    super(ATTRIBUTE_NAME);

    if (!((constantValue instanceof CstString) ||
           (constantValue instanceof CstInteger) ||
           (constantValue instanceof CstLong) ||
           (constantValue instanceof CstFloat) ||
           (constantValue instanceof CstDouble))) {
        if (constantValue == null) {
            throw new NullPointerException("constantValue == null");
        }
        throw new IllegalArgumentException("bad type for constantValue");
    }

    this.constantValue = constantValue;
}
 

import com.android.dx.rop.cst.CstLong; //导入依赖的package包/类
/**
 * Returns a rop constant for the specified value.
 *
 * @param value null, a boxed primitive, String, Class, or TypeId.
 */
static TypedConstant getConstant(Object value) {
    if (value == null) {
        return CstKnownNull.THE_ONE;
    } else if (value instanceof Boolean) {
        return CstBoolean.make((Boolean) value);
    } else if (value instanceof Byte) {
        return CstByte.make((Byte) value);
    } else if (value instanceof Character) {
        return CstChar.make((Character) value);
    } else if (value instanceof Double) {
        return CstDouble.make(Double.doubleToLongBits((Double) value));
    } else if (value instanceof Float) {
        return CstFloat.make(Float.floatToIntBits((Float) value));
    } else if (value instanceof Integer) {
        return CstInteger.make((Integer) value);
    } else if (value instanceof Long) {
        return CstLong.make((Long) value);
    } else if (value instanceof Short) {
        return CstShort.make((Short) value);
    } else if (value instanceof String) {
        return new CstString((String) value);
    } else if (value instanceof Class) {
        return new CstType(TypeId.get((Class<?>) value).ropType);
    } else if (value instanceof TypeId) {
        return new CstType(((TypeId) value).ropType);
    } else {
        throw new UnsupportedOperationException("Not a constant: " + value);
    }
}
 

import com.android.dx.rop.cst.CstLong; //导入依赖的package包/类
/**
 * Gets the value type for the given constant.
 *
 * @param cst {@code non-null;} the constant
 * @return the value type; one of the {@code VALUE_*} constants
 * defined by this class
 */
private static int constantToValueType(Constant cst) {
    /*
     * TODO: Constant should probable have an associated enum, so this
     * can be a switch().
     */
    if (cst instanceof CstByte) {
        return VALUE_BYTE;
    } else if (cst instanceof CstShort) {
        return VALUE_SHORT;
    } else if (cst instanceof CstChar) {
        return VALUE_CHAR;
    } else if (cst instanceof CstInteger) {
        return VALUE_INT;
    } else if (cst instanceof CstLong) {
        return VALUE_LONG;
    } else if (cst instanceof CstFloat) {
        return VALUE_FLOAT;
    } else if (cst instanceof CstDouble) {
        return VALUE_DOUBLE;
    } else if (cst instanceof CstString) {
        return VALUE_STRING;
    } else if (cst instanceof CstType) {
        return VALUE_TYPE;
    } else if (cst instanceof CstFieldRef) {
        return VALUE_FIELD;
    } else if (cst instanceof CstMethodRef) {
        return VALUE_METHOD;
    } else if (cst instanceof CstEnumRef) {
        return VALUE_ENUM;
    } else if (cst instanceof CstArray) {
        return VALUE_ARRAY;
    } else if (cst instanceof CstAnnotation) {
        return VALUE_ANNOTATION;
    } else if (cst instanceof CstKnownNull) {
        return VALUE_NULL;
    } else if (cst instanceof CstBoolean) {
        return VALUE_BOOLEAN;
    } else {
        throw new RuntimeException("Shouldn't happen");
    }
}
 

import com.android.dx.rop.cst.CstLong; //导入依赖的package包/类
/** {@inheritDoc} */
public void visitConstant(int opcode, int offset, int length,
        Constant cst, int value) {
    if (cst instanceof CstKnownNull) {
        // This is aconst_null.
        visitNoArgs(opcode, offset, length, null);
        return;
    }

    if (cst instanceof CstInteger) {
        visitLiteralInt(opcode, offset, length, value);
        return;
    }

    if (cst instanceof CstLong) {
        visitLiteralLong(opcode, offset, length,
                         ((CstLong) cst).getValue());
        return;
    }

    if (cst instanceof CstFloat) {
        visitLiteralFloat(opcode, offset, length,
                          ((CstFloat) cst).getIntBits());
        return;
    }

    if (cst instanceof CstDouble) {
        visitLiteralDouble(opcode, offset, length,
                         ((CstDouble) cst).getLongBits());
        return;
    }

    String valueStr = "";
    if (value != 0) {
        valueStr = ", ";
        if (opcode == ByteOps.MULTIANEWARRAY) {
            valueStr += Hex.u1(value);
        } else {
            valueStr += Hex.u2(value);
        }
    }

    observer.parsed(bytes, offset, length,
                    header(offset) + " " + cst + valueStr);
}