soot.util.queue.QueueReader Java Examples

public static long getICFGEdges() {
    if (icfgEdges > 0)
        return icfgEdges;
    ReachableMethods reachableMethods = Scene.v().getReachableMethods();
    JimpleBasedInterproceduralCFG icfg = new JimpleBasedInterproceduralCFG();
    QueueReader<MethodOrMethodContext> listener = reachableMethods.listener();
    while (listener.hasNext()) {
        MethodOrMethodContext next = listener.next();
        SootMethod method = next.method();
        if (!method.hasActiveBody())
            continue;
        Body activeBody = method.getActiveBody();
        for (Unit u : activeBody.getUnits()) {
            List<Unit> succsOf = icfg.getSuccsOf(u);
            icfgEdges += succsOf.size();
            if (icfg.isCallStmt(u)) {
                icfgEdges += icfg.getCalleesOfCallAt(u).size();
            }
            if (icfg.isExitStmt(u)) {
                icfgEdges += icfg.getCallersOf(method).size();
            }
        }
    }
    return icfgEdges;
}
 

/**
 * when thrown method is reached ,method is risk.
 * 
 * @return
 */
private Set<String> getRiskMthds() {
	Set<String> riskMthds = new HashSet<String>();
	QueueReader<MethodOrMethodContext> entryRchMthds = Scene.v().getReachableMethods().listener();
	while (entryRchMthds.hasNext()) {
		SootMethod method = entryRchMthds.next().method();
		if (thrownMthds.contains(method.getSignature()))
			riskMthds.add(method.getSignature());
	}
	return riskMthds;
}
 

/**
 * Removes all outgoing edges that start at the given unit
 * @param u The unit from which to remove all outgoing edges
 * @return True if at least one edge has been removed, otherwise false
 */
public boolean removeAllEdgesOutOf(Unit u) {
	boolean hasRemoved = false;
	for (QueueReader<Edge> edgeRdr = listener(); edgeRdr.hasNext(); ) {
		Edge e = edgeRdr.next();
		if (e.srcUnit() == u) {
			removeEdge(e);
			hasRemoved = true;
		}
	}
	return hasRemoved;
}
 

/**
 * Swaps an invocation statement. All edges that previously went from the
 * given statement to some callee now go from the new statement to the same
 * callee. This method is intended to be used when a Jimple statement is
 * replaced, but the replacement does not semantically affect the edges.
 * @param out The old statement
 * @param in The new statement
 * @return True if at least one edge was affected by this operation
 */
public boolean swapEdgesOutOf(Stmt out, Stmt in) {
	boolean hasSwapped = false;
	for (QueueReader<Edge> edgeRdr = listener(); edgeRdr.hasNext(); ) {
		Edge e = edgeRdr.next();
		if (e.srcUnit() == out) {
			removeEdge(e);
			addEdge(new Edge(e.getSrc(), in, e.getTgt()));
			hasSwapped = true;
		}
	}
	return hasSwapped;
}
 

public String toString() {
    QueueReader<Edge> reader = listener();
    StringBuffer out = new StringBuffer();
    while(reader.hasNext()) {
        Edge e = (Edge) reader.next();
        out.append( e.toString() + "\n" );
    }
    return out.toString();
}
 

public void apply() {
    if (applied)
        return;
    ReachableMethods reachableMethods = Scene.v().getReachableMethods();
    QueueReader<MethodOrMethodContext> listener = reachableMethods.listener();
    while (listener.hasNext()) {
        SootMethod method = listener.next().method();
        if (method.hasActiveBody()) {
            internalTransform(method.getActiveBody(), "", new HashMap<>());
        }
    }
    applied = true;
}
 

public MatcherTransition(State from, String methodMatcher, Parameter param, State to, Type type) {
    super(from, to);
    this.type = type;
    this.param = param;
    ReachableMethods methods = Scene.v().getReachableMethods();
    QueueReader<MethodOrMethodContext> listener = methods.listener();
    while (listener.hasNext()) {
        MethodOrMethodContext next = listener.next();
        SootMethod method = next.method();
        if (Pattern.matches(methodMatcher, method.getSignature())) {
            matchingMethods.add(method);
        }
    }
}
 

/** Returns a QueueReader object containing all edges added so far, and
 * which will be informed of any new edges that are later added to
 * the graph. */
public QueueReader<Edge> listener() {
    return reader.clone();
}
 

/** Returns a QueueReader object which will contain ONLY NEW edges
 * which will be added to the graph.
 */
public QueueReader<Edge> newListener() {
    return stream.reader();
}
 

public QueueReader<AllocNode> allocNodeListener() { return newAllocNodes.reader(); } 

public QueueReader<Node> edgeReader() { return edgeQueue.reader(); }