public void apply(Switch sw) { e.apply(sw); }
public Node getNode(Value v) { v.apply(this); return getNode(); }
public String printValueAssignment(Value value, String varName) { suggestVariableName(varName); value.apply(this); return getLastAssignedVarName(); }
protected ThrowableSet mightThrow(Value v) { ValueSwitch sw = valueSwitch(); v.apply(sw); return sw.getResult(); }
public void caseArrayRef(ArrayRef v) { String oldName = varName; Value base = v.getBase(); suggestVariableName("base"); String baseName = varName; base.apply(this); Value index = v.getIndex(); suggestVariableName("index"); String indexName = varName; index.apply(this); p.println("Value " + oldName + " = Jimple.v().newArrayRef(" + baseName + ", " + indexName + ");"); varName = oldName; }
public void caseNegExpr(NegExpr v) { String oldName = varName; Value op = v.getOp(); suggestVariableName("op"); String opName = varName; op.apply(this); p.println("Value " + oldName + " = Jimple.v().newNegExpr(" + opName + ");"); varName = oldName; }
public void caseLengthExpr(LengthExpr v) { String oldName = varName; Value op = v.getOp(); suggestVariableName("op"); String opName = varName; op.apply(this); p.println("Value " + oldName + " = Jimple.v().newLengthExpr(" + opName + ");"); varName = oldName; }
@Override public void caseIfStmt(IfStmt stmt) { Stmt target = stmt.getTarget(); exprV.setOrigStmt(stmt); exprV.setTargetForOffset(target); stmt.getCondition().apply(exprV); }
@Override final public void caseThrowStmt(ThrowStmt ts) { ts.getOp().apply(MethodNodeFactory.this); mpag.addOutEdge(getNode(), pag.nodeFactory().caseThrow()); } });
@Override public void caseVirtualInvokeExpr(VirtualInvokeExpr v) { if (isReflectionNewInstance(v)) { NewInstanceNode newInstanceNode = pag.makeNewInstanceNode(v, Scene.v().getObjectType(), method); v.getBase().apply(this); Node srcNode = getNode(); mpag.addInternalEdge(srcNode, newInstanceNode); setResult(newInstanceNode); } else { throw new RuntimeException("Unhandled case of VirtualInvokeExpr"); } }
@Override final public void caseReturnStmt(ReturnStmt rs) { if (!(rs.getOp().getType() instanceof RefLikeType)) { return; } rs.getOp().apply(MethodNodeFactory.this); Node retNode = getNode(); mpag.addInternalEdge(retNode, caseRet()); }
@Override final public void caseCastExpr(CastExpr ce) { Pair<Expr, String> castPair = new Pair<Expr, String>(ce, PointsToAnalysis.CAST_NODE); ce.getOp().apply(this); Node opNode = getNode(); Node castNode = pag.makeLocalVarNode(castPair, ce.getCastType(), method); mpag.addInternalEdge(opNode, castNode); setResult(castNode); }
@Override final public void casePhiExpr(PhiExpr e) { Pair<Expr, String> phiPair = new Pair<Expr, String>(e, PointsToAnalysis.PHI_NODE); Node phiNode = pag.makeLocalVarNode(phiPair, e.getType(), method); for (Value op : e.getValues()) { op.apply(MethodNodeFactory.this); Node opNode = getNode(); mpag.addInternalEdge(opNode, phiNode); } setResult(phiNode); }
public void caseNewArrayExpr(NewArrayExpr v) { String oldName = varName; Value size = v.getSize(); suggestVariableName("size"); String sizeName = varName; size.apply(this); suggestVariableName("type"); String lhsName = varName; ttp.setVariableName(varName); v.getType().apply(ttp); p.println("Value " + oldName + " = Jimple.v().newNewArrayExpr(" + lhsName + ", " + sizeName + ");"); varName = oldName; }
l.apply(MethodNodeFactory.this); Node dest = getNode(); r.apply(MethodNodeFactory.this); Node src = getNode(); if (l instanceof InstanceFieldRef) { ((InstanceFieldRef) l).getBase().apply(MethodNodeFactory.this); pag.addDereference((VarNode) getNode()); ((InstanceFieldRef) r).getBase().apply(MethodNodeFactory.this); pag.addDereference((VarNode) getNode()); } else if (r instanceof StaticFieldRef) {
@Override final public void caseIdentityStmt(IdentityStmt is) { if (!(is.getLeftOp().getType() instanceof RefLikeType)) { return; } Value leftOp = is.getLeftOp(); Value rightOp = is.getRightOp(); leftOp.apply(MethodNodeFactory.this); Node dest = getNode(); rightOp.apply(MethodNodeFactory.this); Node src = getNode(); mpag.addInternalEdge(src, dest); // in case library mode is activated add allocations to any // possible type of this local and // parameters of accessible methods int libOption = pag.getCGOpts().library(); if (libOption != CGOptions.library_disabled && (accessibilityOracle.isAccessible(method))) { if (rightOp instanceof IdentityRef) { Type rt = rightOp.getType(); rt.apply(new SparkLibraryHelper(pag, src, method)); } } }
public void caseNewMultiArrayExpr(NewMultiArrayExpr v) { p.openBlock(); String oldName = varName; ttp.setVariableName("arrayType"); v.getType().apply(ttp); p.println("List<IntConstant> sizes = new LinkedList<IntConstant>();"); int i = 0; for (Value s : v.getSizes()) { this.suggestVariableName("size" + i); s.apply(this); i++; p.println("sizes.add(sizes" + i + ");"); } p.println("Value " + oldName + " = Jimple.v().newNewMultiArrayExpr(arrayType, sizes);"); varName = oldName; p.closeBlock(); }
lvalue.apply(new AbstractJimpleValueSwitch() { public void caseArrayRef(ArrayRef v) { ((ConvertToBaf) (v.getBase())).convertToBaf(context, out);
for (Value v : args) { final int j = index; v.apply(new ConstantSwitch() {