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();
}
}