import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
	p.openBlock();
	String varName = printValueAssignment(stmt.getKey(),"key");
	
	int lowIndex= stmt.getLowIndex();
	p.println("int lowIndex=" + lowIndex + ";");
	

	int highIndex= stmt.getHighIndex();
	p.println("int highIndex=" + highIndex + ";");
	
	p.println("List<Unit> targets = new LinkedList<Unit>();");
	for(Unit s: stmt.getTargets()) {
		String nameOfJumpTarget = nameOfJumpTarget(s);
		p.println("targets.add("+nameOfJumpTarget+")");
	}
	
	Unit defaultTarget = stmt.getDefaultTarget();
	p.println("Unit defaultTarget = " + nameOfJumpTarget(defaultTarget) + ";");

	printStmt(stmt, varName, "lowIndex", "highIndex", "targets", "defaultTarget");
	
	p.closeBlock();
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
private void convertTableSwitchInsn(TableSwitchInsnNode insn) {
	StackFrame frame = getFrame(insn);
	if (units.containsKey(insn)) {
		frame.mergeIn(pop());
		return;
	}
	Operand key = popImmediate();
	UnitBox dflt = Jimple.v().newStmtBox(null);
	List<UnitBox> targets = new ArrayList<UnitBox>(insn.labels.size());
	labels.put(insn.dflt, dflt);
	for (LabelNode ln : insn.labels) {
		UnitBox box = Jimple.v().newStmtBox(null);
		targets.add(box);
		labels.put(ln, box);
	}
	TableSwitchStmt tss = Jimple.v().newTableSwitchStmt(key.stackOrValue(),
			insn.min, insn.max, targets, dflt);
	key.addBox(tss.getKeyBox());
	frame.in(key);
	frame.boxes(tss.getKeyBox());
	setUnit(insn, tss);
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
	Value key = stmt.getKey();

	if (key instanceof Local) {
		if (!ClassHierarchy.v().typeNode(((Local) key).getType())
				.hasAncestor_1(ClassHierarchy.v().INT)) {
			if (fix) {
				stmt.setKey(insertCast((Local) key, IntType.v(), stmt));
			} else {
				error("Type Error(20)");
			}
		}
		resolver.typeVariable((Local) key).addParent(resolver.INT);
	}
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
	if (uses) {
		Value key = stmt.getKey();

		if (key instanceof Local) {
			resolver.typeVariable((Local) key).addParent(resolver.INT);
		}
	}
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
	if (uses) {
		Value key = stmt.getKey();

		if (key instanceof Local) {
			resolver.typeVariable((Local) key).addParent(resolver.typeVariable(IntType.v()));
		}
	}
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
@Override
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
       exprV.setOrigStmt(stmt);
       constantV.setOrigStmt(stmt);
	// create payload that references the switch's targets
	int firstKey = stmt.getLowIndex();		
	List<Unit> targets = stmt.getTargets();
	PackedSwitchPayload payload = new PackedSwitchPayload(firstKey, targets);
	switchPayloads.add(payload);
	// create packed-switch instruction that references the payload
	Value key = stmt.getKey();
	Stmt defaultTarget = (Stmt) stmt.getDefaultTarget();
       addInsn(buildSwitchInsn(Opcode.PACKED_SWITCH, key, defaultTarget,
       		payload, stmt), stmt);
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
@Override
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
	logger.fine("\n > > > Table switch statement identified < < <");
	valueSwitch.callingStmt = stmt;
	logger.finest("Use and def boxes of SwitchStmt: "
			+ stmt.getUseAndDefBoxes().toString());

	// Check for all values in the condition if they are a constant value
	// or if they are stored in a local. In the second case the local is
	// added
	// to a list for the locals.
	List<ValueBox> valueList = stmt.getUseBoxes();
	ArrayList<Local> localList = new ArrayList<Local>();
	for (ValueBox v : valueList) {
		Value val = v.getValue();
		if (val instanceof Local) {
			localList.add((Local) val);
			logger.fine("New local added to local-list of SwitchStmt: "
					+ val);
		}
	}

	int localListLength = localList.size();

	Local[] arguments = new Local[localListLength];

	for (int i = 0; i < localListLength; i++) {
		arguments[i] = localList.get(i);
	}

	JimpleInjector.checkCondition(stmt, arguments);

}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
@Override
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
	logger.fine("\n > > > Table switch statement identified < < <");
	logger.finest("Use and def boxes of SwitchStmt: "
			+ stmt.getUseAndDefBoxes().toString());

	// Check for all values in the condition if they are a constant value
	// or if they are stored in a local. In the second case the local is
	// added
	// to a list for the locals.
	List<ValueBox> valueList = stmt.getUseBoxes();
	ArrayList<Local> localList = new ArrayList<Local>();
	for (ValueBox v : valueList) {
		Value val = v.getValue();
		if (val instanceof Local) {
			localList.add((Local) val);
			logger.fine("New local added to local-list of SwitchStmt: "
					+ val);
		}
	}

	int localListLength = localList.size();

	Local[] arguments = new Local[localListLength];

	for (int i = 0; i < localListLength; i++) {
		arguments[i] = localList.get(i);
	}

	JimpleInjector.checkCondition(stmt, arguments);

}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
@Override
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
	throw new RuntimeException("todo");
	
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
public void caseTableSwitchStmt(TableSwitchStmt stmt)
{
	stmt.setKey(this.uv.visit(stmt.getKey(), IntType.v(), stmt));
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
@Override
public void caseTableSwitchStmt(TableSwitchStmt s) {
    result = result.add(mightThrow(s.getKey()));
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
@Override
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
    handleBranch(stmt.getKey(), new TableSwitchProgramCounterTrigger(stmt));
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
public TableSwitchProgramCounterTrigger(TableSwitchStmt stmt) {
    this.stmt = stmt;
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
public final TableSwitchStmt getTableSwitchStmt() {
    return stmt;
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
/**
 * Method, which should process the given statement of type
 * {@link TableSwitchStmt}, but is not implemented in the current version of
 * this method. If method will be called an exception is thrown.
 * 
 * @param stmt
 *            Statement that should be processed to check for security
 *            violations.
 * @see soot.jimple.StmtSwitch#caseTableSwitchStmt(soot.jimple.TableSwitchStmt)
 * @throws UnimplementedSwitchException
 *             Method throws always this exception, because the method is
 *             not implemented.
 */
@Override
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
    throw new SwitchException(getMsg("exception.analysis.switch.not_implemented",
                                     stmt.toString(),
                                     getSourceLine(),
                                     stmt.getClass().getSimpleName(),
                                     this.getClass().getSimpleName()));
}
 

import soot.jimple.TableSwitchStmt; //导入依赖的package包/类
/**
 * DOC
 * 
 * @see soot.jimple.StmtSwitch#caseTableSwitchStmt(soot.jimple.TableSwitchStmt)
 */
@Override
public void caseTableSwitchStmt(TableSwitchStmt stmt) {
    // TODO: Consider reaction
}