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.logic;
 
 import java.util.List;
 import java.util.Map;
 
 import soot.Body;
 import soot.Unit;
 
 public class LoopFinder extends BodyTransformer {
 
     private UnitGraph g;
 
     private HashMap<StmtList<Stmt>> loops;
 
     public Collection<Looploops(){
         Collection<Loopresult = new HashSet<Loop>();
         for (Map.Entry<Stmt,List<Stmt>> entry : .entrySet()) {
             result.add(new Loop(entry.getKey(),entry.getValue(),));
         }
         return result;
     }
     
     protected void internalTransform (Body bString phaseNameMap options){
     
          = new ExceptionalUnitGraph(b);
         MHGDominatorsFinder a = new MHGDominatorsFinder();
         
          = new HashMap<StmtList<Stmt>>();
         
         Iterator<UnitstmtsIt = b.getUnits().iterator();
         while (stmtsIt.hasNext()){
             Stmt s = (Stmt)stmtsIt.next();
 
             List<Unitsuccs = .getSuccsOf(s);
             Collection<Unitdominaters = (Collection<Unit>)a.getDominators(s);
 
             ArrayList<Stmtheaders = new ArrayList<Stmt>();
 
             Iterator<UnitsuccsIt = succs.iterator();
             while (succsIt.hasNext()){
                 Stmt succ = (Stmt)succsIt.next();
                 if (dominaters.contains(succ)){
                 	//header succeeds and dominates s, we have a loop
                     headers.add(succ);
                 }
             }
 
             Iterator<StmtheadersIt = headers.iterator();
             while (headersIt.hasNext()){
                 Stmt header = headersIt.next();
                 List<StmtloopBody = getLoopBodyFor(headers);
 
                 // for now just print out loops as sets of stmts
                 //System.out.println("FOUND LOOP: Header: "+header+" Body: "+loopBody);
                 if (.containsKey(header)){
                     // merge bodies
                     List<Stmtlb1 = .get(header);
                     .put(headerunion(lb1loopBody));
                 }
                 else {
                     .put(headerloopBody);
                 }
             }
         }
 
     }
     
 
     private List<StmtgetLoopBodyFor(Stmt headerStmt node){
    
        ArrayList<StmtloopBody = new ArrayList<Stmt>();
        Stack<Unitstack = new Stack<Unit>();
        loopBody.add(header);
        stack.push(node);
        while (!stack.isEmpty()){
            Stmt next = (Stmt)stack.pop();
            if (!loopBody.contains(next)){
                // add next to loop body
                loopBody.add(0, next);
                // put all preds of next on stack
                Iterator<Unitit = .getPredsOf(next).iterator();
                while (it.hasNext()){
                    stack.push(it.next());
                }
            }
        }
        
        assert (node==header && loopBody.size()==1) || loopBody.get(loopBody.size()-2)==node;
        assert loopBody.get(loopBody.size()-1)==header;
        
        return loopBody;
    }
    private List<Stmtunion(List<Stmtl1List<Stmtl2){
        Iterator<Stmtit = l2.iterator();
        while (it.hasNext()){
            Stmt next = it.next();
            if (!l1.contains(next)){
                l1.add(next);
            }
        }
        return l1;
    }
New to GrepCode? Check out our FAQ X