private static void processClassRec( ClassNode node, final HashMap<ClassWrapper, MethodWrapper> mapClassMeths, final HashSet<ClassWrapper> setFound) { final ClassWrapper wrapper = node.wrapper; // search code for (MethodWrapper meth : wrapper.getMethods()) { RootStatement root = meth.root; if (root != null) { DirectGraph graph = meth.getOrBuildGraph(); graph.iterateExprents( new DirectGraph.ExprentIterator() { public int processExprent(Exprent exprent) { for (Entry<ClassWrapper, MethodWrapper> ent : mapClassMeths.entrySet()) { if (replaceInvocations(exprent, ent.getKey(), ent.getValue())) { setFound.add(ent.getKey()); } } return 0; } }); } } // search initializers for (int j = 0; j < 2; j++) { VBStyleCollection<Exprent, String> initializers = j == 0 ? wrapper.getStaticFieldInitializers() : wrapper.getDynamicFieldInitializers(); for (int i = 0; i < initializers.size(); i++) { for (Entry<ClassWrapper, MethodWrapper> ent : mapClassMeths.entrySet()) { Exprent exprent = initializers.get(i); if (replaceInvocations(exprent, ent.getKey(), ent.getValue())) { setFound.add(ent.getKey()); } String cl = isClass14Invocation(exprent, ent.getKey(), ent.getValue()); if (cl != null) { initializers.set( i, new ConstExprent(VarType.VARTYPE_CLASS, cl.replace('.', '/'), exprent.bytecode)); setFound.add(ent.getKey()); } } } } // iterate nested classes for (ClassNode nd : node.nested) { processClassRec(nd, mapClassMeths, setFound); } }
public boolean containsStatementStrict(Statement stat) { if (stats.contains(stat)) { return true; } for (int i = 0; i < stats.size(); i++) { if (stats.get(i).containsStatementStrict(stat)) { return true; } } return false; }
public void replaceStatement(Statement oldstat, Statement newstat) { for (StatEdge edge : oldstat.getAllPredecessorEdges()) { oldstat.removePredecessor(edge); edge.getSource().changeEdgeNode(DIRECTION_FORWARD, edge, newstat); newstat.addPredecessor(edge); } for (StatEdge edge : oldstat.getAllSuccessorEdges()) { oldstat.removeSuccessor(edge); edge.setSource(newstat); newstat.addSuccessor(edge); } int statindex = stats.getIndexByKey(oldstat.id); stats.removeWithKey(oldstat.id); stats.addWithKeyAndIndex(statindex, newstat, newstat.id); newstat.setParent(this); newstat.post = oldstat.post; if (first == oldstat) { first = newstat; } List<StatEdge> lst = new ArrayList<StatEdge>(oldstat.getLabelEdges()); for (int i = lst.size() - 1; i >= 0; i--) { StatEdge edge = lst.get(i); if (edge.getSource() != newstat) { newstat.addLabeledEdge(edge); } else { if (this == edge.getDestination() || this.containsStatementStrict(edge.getDestination())) { edge.closure = null; } else { this.addLabeledEdge(edge); } } } oldstat.getLabelEdges().clear(); }
public List<Statement> getPostReversePostOrderList(List<Statement> lstexits) { List<Statement> res = new ArrayList<Statement>(); if (lstexits == null) { StrongConnectivityHelper schelper = new StrongConnectivityHelper(this); lstexits = StrongConnectivityHelper.getExitReps(schelper.getComponents()); } HashSet<Statement> setVisited = new HashSet<Statement>(); for (Statement exit : lstexits) { addToPostReversePostOrderList(exit, res, setVisited); } if (res.size() != stats.size()) { throw new RuntimeException("computing post reverse post order failed!"); } return res; }
public void initSimpleCopy() { if (!stats.isEmpty()) { first = stats.get(0); } }
public void collapseNodesToStatement(Statement stat) { Statement head = stat.getFirst(); Statement post = stat.getPost(); VBStyleCollection<Statement, Integer> setNodes = stat.getStats(); // post edges if (post != null) { for (StatEdge edge : post.getEdges(STATEDGE_DIRECT_ALL, DIRECTION_BACKWARD)) { if (stat.containsStatementStrict(edge.getSource())) { edge.getSource().changeEdgeType(DIRECTION_FORWARD, edge, StatEdge.TYPE_BREAK); stat.addLabeledEdge(edge); } } } // regular head edges for (StatEdge prededge : head.getAllPredecessorEdges()) { if (prededge.getType() != StatEdge.TYPE_EXCEPTION && stat.containsStatementStrict(prededge.getSource())) { prededge.getSource().changeEdgeType(DIRECTION_FORWARD, prededge, StatEdge.TYPE_CONTINUE); stat.addLabeledEdge(prededge); } head.removePredecessor(prededge); prededge.getSource().changeEdgeNode(DIRECTION_FORWARD, prededge, stat); stat.addPredecessor(prededge); } if (setNodes.containsKey(first.id)) { first = stat; } // exception edges Set<Statement> setHandlers = new HashSet<Statement>(head.getNeighbours(StatEdge.TYPE_EXCEPTION, DIRECTION_FORWARD)); for (Statement node : setNodes) { setHandlers.retainAll(node.getNeighbours(StatEdge.TYPE_EXCEPTION, DIRECTION_FORWARD)); } if (!setHandlers.isEmpty()) { for (StatEdge edge : head.getEdges(StatEdge.TYPE_EXCEPTION, DIRECTION_FORWARD)) { Statement handler = edge.getDestination(); if (setHandlers.contains(handler)) { if (!setNodes.containsKey(handler.id)) { stat.addSuccessor(new StatEdge(stat, handler, edge.getExceptions())); } } } for (Statement node : setNodes) { for (StatEdge edge : node.getEdges(StatEdge.TYPE_EXCEPTION, DIRECTION_FORWARD)) { if (setHandlers.contains(edge.getDestination())) { node.removeSuccessor(edge); } } } } if (post != null && !stat.getNeighbours(StatEdge.TYPE_EXCEPTION, DIRECTION_FORWARD) .contains(post)) { // TODO: second condition redundant? stat.addSuccessor(new StatEdge(StatEdge.TYPE_REGULAR, stat, post)); } // adjust statement collection for (Statement st : setNodes) { stats.removeWithKey(st.id); } stats.addWithKey(stat, stat.id); stat.setAllParent(); stat.setParent(this); stat.buildContinueSet(); // monitorenter and monitorexit stat.buildMonitorFlags(); if (stat.type == TYPE_SWITCH) { // special case switch, sorting leaf nodes ((SwitchStatement) stat).sortEdgesAndNodes(); } }