import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload; //导入依赖的package包/类
@Nonnull
private BuilderSparseSwitchPayload newBuilderSparseSwitchPayload(@Nonnull MethodLocation location,
                                                                 @Nonnull int[] codeAddressToIndex,
                                                                 @Nonnull SparseSwitchPayload instruction) {
    List<? extends SwitchElement> switchElements = instruction.getSwitchElements();
    if (switchElements.size() == 0) {
        return new BuilderSparseSwitchPayload(null);
    }

    MethodLocation switchLocation = findSwitchForPayload(location);
    int baseAddress;
    if (switchLocation == null) {
        baseAddress = 0;
    } else {
        baseAddress = switchLocation.codeAddress;
    }

    List<SwitchLabelElement> labelElements = Lists.newArrayList();
    for (SwitchElement element : switchElements) {
        labelElements.add(new SwitchLabelElement(element.getKey(),
                newLabel(codeAddressToIndex, element.getOffset() + baseAddress)));
    }

    return new BuilderSparseSwitchPayload(labelElements);
}
 

import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload; //导入依赖的package包/类
public static InstructionMethodItem makeInstructionFormatMethodItem(
        MethodDefinition methodDef, int codeAddress, Instruction instruction) {

    if (instruction instanceof OffsetInstruction) {
        return new OffsetInstructionFormatMethodItem(methodDef.classDef.options, methodDef, codeAddress,
                (OffsetInstruction)instruction);
    }

    if (instruction instanceof UnresolvedOdexInstruction) {
        return new UnresolvedOdexInstructionMethodItem(methodDef, codeAddress,
                (UnresolvedOdexInstruction)instruction);
    }

    switch (instruction.getOpcode().format) {
        case ArrayPayload:
            return new ArrayDataMethodItem(methodDef, codeAddress, (ArrayPayload)instruction);
        case PackedSwitchPayload:
            return new PackedSwitchMethodItem(methodDef, codeAddress, (PackedSwitchPayload)instruction);
        case SparseSwitchPayload:
            return new SparseSwitchMethodItem(methodDef, codeAddress, (SparseSwitchPayload)instruction);
        default:
            return new InstructionMethodItem<Instruction>(methodDef, codeAddress, instruction);
    }
}
 

import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload; //导入依赖的package包/类
protected Stmt switchStatement(DexBody body, Instruction targetData, Local key) {
     SparseSwitchPayload i = (SparseSwitchPayload) targetData;
     List<? extends SwitchElement> seList = i.getSwitchElements();

     // the default target always follows the switch statement
     int defaultTargetAddress = codeAddress + instruction.getCodeUnits();
     Unit defaultTarget = body.instructionAtAddress(defaultTargetAddress).getUnit();

     List<IntConstant> lookupValues = new ArrayList<IntConstant>();
     List<Unit> targets = new ArrayList<Unit>();
     for(SwitchElement se: seList) {
       lookupValues.add(IntConstant.v(se.getKey()));
       int offset = se.getOffset();
       targets.add(body.instructionAtAddress(codeAddress + offset).getUnit());
     }
     switchStmt = Jimple.v().newLookupSwitchStmt(key, lookupValues, targets, defaultTarget);
     setUnit(switchStmt);
     
     if (IDalvikTyper.ENABLE_DVKTYPER) {
Debug.printDbg(IDalvikTyper.DEBUG, "constraint: "+ switchStmt);
         DalvikTyper.v().setType(switchStmt.getKeyBox(), IntType.v(), true);
     }
     
     return switchStmt;
 }
 

import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload; //导入依赖的package包/类
@Nonnull
public static ImmutableSparseSwitchPayload of(SparseSwitchPayload instruction) {
    if (instruction instanceof ImmutableSparseSwitchPayload) {
        return (ImmutableSparseSwitchPayload)instruction;
    }
    return new ImmutableSparseSwitchPayload(
            instruction.getSwitchElements());
}
 

import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload; //导入依赖的package包/类
public static ImmutableSparseSwitchPayload of(SparseSwitchPayload instruction) {
    if (instruction instanceof ImmutableSparseSwitchPayload) {
        return (ImmutableSparseSwitchPayload)instruction;
    }
    return new ImmutableSparseSwitchPayload(
            instruction.getSwitchElements());
}
 

import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload; //导入依赖的package包/类
@Nonnull
public static ImmutableSparseSwitchPayload of(SparseSwitchPayload instruction) {
    if (instruction instanceof ImmutableSparseSwitchPayload) {
        return (ImmutableSparseSwitchPayload) instruction;
    }
    return new ImmutableSparseSwitchPayload(
            instruction.getSwitchElements());
}
 

import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload; //导入依赖的package包/类
private static int calculateComplexity(@Nonnull DexBackedMethodImplementation implementation) {
    // Cyclomatic complexity = <branches> - <exits> + 2
    int branches = 0;
    int exits = 0;
    for (Instruction instruction : implementation.getInstructions()) {
        switch (instruction.getOpcode()) {
            case IF_EQ:
            case IF_EQZ:
            case IF_GE:
            case IF_GEZ:
            case IF_GT:
            case IF_GTZ:
            case IF_LE:
            case IF_LEZ:
            case IF_LT:
            case IF_LTZ:
            case IF_NE:
            case IF_NEZ:
                branches += 2;
                break;
            case PACKED_SWITCH_PAYLOAD:
                branches += ((PackedSwitchPayload) instruction).getSwitchElements().size();
                break;
            case RETURN:
            case RETURN_OBJECT:
            case RETURN_VOID:
            case RETURN_VOID_BARRIER:
            case RETURN_VOID_NO_BARRIER:
            case RETURN_WIDE:
                exits += 1;
                break;
            case SPARSE_SWITCH_PAYLOAD:
                branches += ((SparseSwitchPayload) instruction).getSwitchElements().size();
                break;
            case THROW:
            case THROW_VERIFICATION_ERROR:
                exits += 1;
                break;
        }
    }
    return branches - exits + 2;
}