Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Soot - a J*va Optimization Framework
   * Copyright (C) 2004 Jennifer Lhotak
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
 
 package soot.jimple.toolkits.annotation.callgraph;
 
 import soot.*;
 import java.util.*;
 import soot.jimple.*;
 import soot.options.*;

A scene transformer that creates a graphical callgraph.
 
 public class CallGraphGrapher extends SceneTransformer
 { 
     public CallGraphGrapher(Singletons.Global g){}
     public static CallGraphGrapher v() { return G.v().soot_jimple_toolkits_annotation_callgraph_CallGraphGrapher();}
 
     private CallGraph cg;
     private boolean showLibMeths;
     
     private ArrayList<MethInfogetTgtMethods(SootMethod methodboolean recurse){
         //G.v().out.println("meth for tgts: "+method);
         if (!method.hasActiveBody()){
             return new ArrayList<MethInfo>();
         }
         Body b = method.getActiveBody();
         ArrayList<MethInfolist = new ArrayList<MethInfo>();
         Iterator sIt = b.getUnits().iterator();
         while (sIt.hasNext()){
             Stmt s = (StmtsIt.next();
             Iterator edges = .edgesOutOf(s);
             while (edges.hasNext()){
                 Edge e = (Edge)edges.next();
                 SootMethod sm = e.tgt();
                 //G.v().out.println("found target method: "+sm);
                 
                 if (sm.getDeclaringClass().isLibraryClass()){
                     if (isShowLibMeths()){
                         if (recurse){
                             list.add(new MethInfo(smhasTgtMethods(sm) | hasSrcMethods(sm), e.kind()));
                         }
                         else {
                             list.add(new MethInfo(smtruee.kind()));
                         }
                     }
                 }
                 else {
                     if (recurse){
                         list.add(new MethInfo(smhasTgtMethods(sm) | hasSrcMethods(sm), e.kind()));
                     }
                     else {
                         list.add(new MethInfo(smtruee.kind()));
                     }
                 }
             }
         }
         return list;
     }
 
     private boolean hasTgtMethods(SootMethod meth){
         ArrayList<MethInfolist = getTgtMethods(methfalse);
         if (!list.isEmpty()) return true;
         else return false;
     }
 
     private boolean hasSrcMethods(SootMethod meth){
         ArrayList<MethInfolist = getSrcMethods(methfalse);
         if (list.size() > 1) return true;
         else return false;
     }
     
     private ArrayList<MethInfogetSrcMethods(SootMethod methodboolean recurse){
         //G.v().out.println("meth for srcs: "+method);
         ArrayList<MethInfolist = new ArrayList<MethInfo>();
         
         forIterator momcIt = .get(method).iterator(); momcIt.hasNext(); ) {
             final MethodOrMethodContext momc = (MethodOrMethodContextmomcIt.next();
             Iterator callerEdges = .edgesInto(momc);
             while (callerEdges.hasNext()){
                 Edge callEdge = (Edge)callerEdges.next();
                 SootMethod methodCaller = callEdge.src();
                if (methodCaller.getDeclaringClass().isLibraryClass()){
                    if (isShowLibMeths()){
                        if (recurse){
                            list.add(new MethInfo(methodCallerhasTgtMethods(methodCaller) | hasSrcMethods(methodCaller), callEdge.kind()));
                        }
                        else {
                            list.add(new MethInfo(methodCallertruecallEdge.kind()));
                        }
                    }
                }
                else {
                    if (recurse){
                        list.add(new MethInfo(methodCallerhasTgtMethods(methodCaller) | hasSrcMethods(methodCaller), callEdge.kind()));
                    }
                    else {
                        list.add(new MethInfo(methodCallertruecallEdge.kind()));
                    }
                }
            } 
        }
        return list;
    }
    
    protected void internalTransform(String phaseNameMap options){
        
        CGGOptions opts = new CGGOptions(options);
        if (opts.show_lib_meths()){
            setShowLibMeths(true);
        }
         = Scene.v().getCallGraph();
        if (Options.v().interactive_mode()){
            reset();
        }
    }
    public void reset() {
        if ( == null){
             = new MethodToContexts(Scene.v().getReachableMethods().listener());
        }
        
        if(Scene.v().hasCallGraph()) {
	        SootClass sc = Scene.v().getMainClass();
	        SootMethod sm = getFirstMethod(sc);
	        //G.v().out.println("got first method");
	        ArrayList<MethInfotgts = getTgtMethods(smtrue);
	        //G.v().out.println("got tgt methods");
	        ArrayList<MethInfosrcs = getSrcMethods(smtrue);
	        //G.v().out.println("got src methods");
	        CallGraphInfo info = new CallGraphInfo(smtgtssrcs);
	        //G.v().out.println("will handle new call graph");
	        InteractionHandler.v().handleCallGraphStart(infothis);
        }
    }
    private SootMethod getFirstMethod(SootClass sc){
        ArrayList paramTypes = new ArrayList();
        paramTypes.add(soot.ArrayType.v(soot.RefType.v("java.lang.String"), 1));
        if (sc.declaresMethod("main"paramTypes, soot.VoidType.v())){
            return sc.getMethod("main"paramTypes, soot.VoidType.v());
        }
        else {
            return (SootMethod)sc.getMethods().get(0);
        }
    }
    
    public void handleNextMethod(){
        if (!getNextMethod().hasActiveBody()) return;
        ArrayList<MethInfotgts = getTgtMethods(getNextMethod(), true);
        //System.out.println("for: "+getNextMethod().getName()+" tgts: "+tgts);
        ArrayList<MethInfosrcs = getSrcMethods(getNextMethod(), true);
        //System.out.println("for: "+getNextMethod().getName()+" srcs: "+srcs);
        CallGraphInfo info = new CallGraphInfo(getNextMethod(), tgtssrcs);
        //System.out.println("sending next method");
        InteractionHandler.v().handleCallGraphPart(info);
        //handleNextMethod();
    }
    
    private SootMethod nextMethod;
    public void setNextMethod(SootMethod m){
         = m;
    }
    public SootMethod getNextMethod(){
        return ;
    }
    public void setShowLibMeths(boolean b){
         = b;
    }
    public boolean isShowLibMeths(){
        return ;
    }
New to GrepCode? Check out our FAQ X