Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Soot - a J*va Optimization Framework
   * Copyright (C) 1997-2000 Etienne Gagnon.  All rights reserved.
   *
   * 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.
  */
 
 /*
  * Modified by the Sable Research Group and others 1997-1999.  
  * See the 'credits' file distributed with Soot for the complete list of
  * contributors.  (Soot is distributed at http://www.sable.mcgill.ca/soot)
  */
 
 
 package soot.jimple.toolkits.typing;
 
 import soot.*;
 import soot.jimple.*;
 import java.util.*;
 
 {
   private TypeResolver resolver;
   private boolean uses;  // if true, include use contraints
   
   private JimpleBody stmtBody;
 
   public ConstraintCollector(TypeResolver resolverboolean uses)
   {
     this. = resolver;
     this. = uses;
 
   }
 
   public void collect(Stmt stmtJimpleBody stmtBody)
   {
     this. = stmtBody;
     stmt.apply(this);
   }
   private void handleInvokeExpr(InvokeExpr ie)
   {
     if(!)
       return;
 
     if(ie instanceof InterfaceInvokeExpr)
       {
 	
 	SootMethodRef method = invoke.getMethodRef();
 	Value base = invoke.getBase();
 	
 	if(base instanceof Local)
 	  {
 	    Local local = (Localbase;
 	    
 	    TypeVariable localType = .typeVariable(local);
 	    
 	    localType.addParent(.typeVariable(method.declaringClass()));
 	  }
 	
 	int count = invoke.getArgCount();
 	
 	for(int i = 0; i < counti++)
 	  {
 	    if(invoke.getArg(iinstanceof Local)
 	      {
 		Local local = (Localinvoke.getArg(i);
 
 		TypeVariable localType = .typeVariable(local);
 
 	      }
 	  }
       }
     else if(ie instanceof SpecialInvokeExpr)
       {
 
 	SootMethodRef method = invoke.getMethodRef();
 	Value base = invoke.getBase();
 
 	if(base instanceof Local)
 	  {
 	    Local local = (Localbase;
 
 	    TypeVariable localType = .typeVariable(local);
 
	    localType.addParent(.typeVariable(method.declaringClass()));
	  }
	int count = invoke.getArgCount();
	for(int i = 0; i < counti++)
	  {
	    if(invoke.getArg(iinstanceof Local)
	      {
		Local local = (Localinvoke.getArg(i);
		TypeVariable localType = .typeVariable(local);
	      }
	  }
      }
    else if(ie instanceof VirtualInvokeExpr)
      {
	SootMethodRef method = invoke.getMethodRef();
	Value base = invoke.getBase();
	if(base instanceof Local)
	  {
	    Local local = (Localbase;
	    TypeVariable localType = .typeVariable(local);
	    localType.addParent(.typeVariable(method.declaringClass()));
	  }
	int count = invoke.getArgCount();
	for(int i = 0; i < counti++)
	  {
	    if(invoke.getArg(iinstanceof Local)
	      {
		Local local = (Localinvoke.getArg(i);
		TypeVariable localType = .typeVariable(local);
	      }
	  }
      }
    else if(ie instanceof StaticInvokeExpr)
      {
	SootMethodRef method = invoke.getMethodRef();
	int count = invoke.getArgCount();
	for(int i = 0; i < counti++)
	  {
	    if(invoke.getArg(iinstanceof Local)
	      {
		Local local = (Localinvoke.getArg(i);
		TypeVariable localType = .typeVariable(local);
	      }
	  }
      }
    else
      {
	throw new RuntimeException("Unhandled invoke expression type: " + ie.getClass());
      }
  }
  public void caseBreakpointStmt(BreakpointStmt stmt)
  {
    // Do nothing
  }
  public void caseInvokeStmt(InvokeStmt stmt)
  {
  }
  public void caseAssignStmt(AssignStmt stmt)
  {
    Value l = stmt.getLeftOp();
    Value r = stmt.getRightOp();
    TypeVariable left = null;
    TypeVariable right = null;
    //******** LEFT ********
    if(l instanceof ArrayRef)
      {
	ArrayRef ref = (ArrayRefl;
	Value base = ref.getBase();
	Value index = ref.getIndex();
	TypeVariable baseType = .typeVariable((Localbase);
	baseType.makeElement();
	left = baseType.element();
	if(index instanceof Local)
	  {
	    if()
	      {
	      }
	  }
      }
    else if(l instanceof Local)
      {
	left = .typeVariable((Locall);
      }
    else if(l instanceof InstanceFieldRef)
      {
	if()
	  {
	    TypeVariable baseType = .typeVariable((Localref.getBase());
	   
	    left = .typeVariable(ref.getField().getType());
	  }
      }
    else if(l instanceof StaticFieldRef)
      {
	if()
	  {
	    StaticFieldRef ref = (StaticFieldRefl;
	    
	    left = .typeVariable(ref.getField().getType());
	  }
      }
    else
      {
	throw new RuntimeException("Unhandled assignment left hand side type: " + l.getClass());
      }
    //******** RIGHT ********
    if(r instanceof ArrayRef)
      {
	ArrayRef ref = (ArrayRefr;
	Value base = ref.getBase();
	Value index = ref.getIndex();
	TypeVariable baseType = .typeVariable((Localbase);
	baseType.makeElement();
	right = baseType.element();
	if(index instanceof Local)
	  {
	    if()
	      {
	      }
	  }
      }
    else if(r instanceof DoubleConstant)
      {
	right = .typeVariable(DoubleType.v());
      }
    else if(r instanceof FloatConstant)
      {
	right = .typeVariable(FloatType.v());
      }
    else if(r instanceof IntConstant)
      {
	right = .typeVariable(IntType.v());
      }
    else if(r instanceof LongConstant)
      {
	right = .typeVariable(LongType.v());
      }
    else if(r instanceof NullConstant)
      {
	right = .typeVariable(NullType.v());
      }
    else if(r instanceof StringConstant)
      {
	right = .typeVariable(RefType.v("java.lang.String"));
      }
    else if(r instanceof ClassConstant)
      {
	right = .typeVariable(RefType.v("java.lang.Class"));
      }
    else if(r instanceof BinopExpr)
      {
	//******** BINOP EXPR ********
	BinopExpr be = (BinopExprr;
	Value lv = be.getOp1();
	Value rv = be.getOp2();
	//******** LEFT ********
	if(lv instanceof Local)
	  {
	    lop = .typeVariable((Locallv);
	  }
	else if(lv instanceof DoubleConstant)
	  {
	    lop = .typeVariable(DoubleType.v());
	  }
	else if(lv instanceof FloatConstant)
	  {
	    lop = .typeVariable(FloatType.v());
	  }
	else if(lv instanceof IntConstant)
	  {
	    lop = .typeVariable(IntType.v());
	  }
	else if(lv instanceof LongConstant)
	  {
	    lop = .typeVariable(LongType.v());
	  }
	else if(lv instanceof NullConstant)
	  {
	    lop = .typeVariable(NullType.v());
	  }
	else if(lv instanceof StringConstant)
	  {
	    lop = .typeVariable(RefType.v("java.lang.String"));
	  }
	else if(lv instanceof ClassConstant)
	  {
	    lop = .typeVariable(RefType.v("java.lang.Class"));
	  }
	else
	  {
	    throw new RuntimeException("Unhandled binary expression left operand type: " + lv.getClass());
	  }
	//******** RIGHT ********
	if(rv instanceof Local)
	  {
	    rop = .typeVariable((Localrv);
	  }
	else if(rv instanceof DoubleConstant)
	  {
	    rop = .typeVariable(DoubleType.v());
	  }
	else if(rv instanceof FloatConstant)
	  {
	    rop = .typeVariable(FloatType.v());
	  }
	else if(rv instanceof IntConstant)
	  {
	    rop = .typeVariable(IntType.v());
	  }
	else if(rv instanceof LongConstant)
	  {
	    rop = .typeVariable(LongType.v());
	  }
	else if(rv instanceof NullConstant)
	  {
	    rop = .typeVariable(NullType.v());
	  }
	else if(rv instanceof StringConstant)
	  {
	    rop = .typeVariable(RefType.v("java.lang.String"));
	  }
	else if(rv instanceof ClassConstant)
	  {
	    rop = .typeVariable(RefType.v("java.lang.Class"));
	  }
	else
	  {
	    throw new RuntimeException("Unhandled binary expression right operand type: " + rv.getClass());
	  }
	if((be instanceof AddExpr) ||
	   (be instanceof SubExpr) ||
	   (be instanceof MulExpr) ||
	   (be instanceof DivExpr) ||
	   (be instanceof RemExpr) ||
	   (be instanceof AndExpr) ||
	   (be instanceof OrExpr) ||
	   (be instanceof XorExpr))
	  {
	    if()
	      {
		rop.addParent(common);
		lop.addParent(common);
	      }
	    
	    if(left != null)
	      {
		rop.addParent(left);
		lop.addParent(left);
	      }
	  }
	else if((be instanceof ShlExpr) ||
		(be instanceof ShrExpr) ||
		(be instanceof UshrExpr))
	  {
	    if()
	      {
	      }
	    
	    right = lop;
	  }
	else if((be instanceof CmpExpr) ||
		(be instanceof CmpgExpr) ||
		(be instanceof CmplExpr) ||
		(be instanceof EqExpr) ||
		(be instanceof GeExpr) ||
		(be instanceof GtExpr) ||
		(be instanceof LeExpr) ||
		(be instanceof LtExpr) ||
		(be instanceof NeExpr))
	  {
	    if()
	      {
		rop.addParent(common);
		lop.addParent(common);
	      }
	    
	    right = .typeVariable(IntType.v());
	  }
	else
	  {
	    throw new RuntimeException("Unhandled binary expression type: " + be.getClass());
	  }
      }
    else if(r instanceof CastExpr)
      {
	CastExpr ce = (CastExprr;
      }
    else if(r instanceof InstanceOfExpr)
      {
	right = .typeVariable(IntType.v());
      }
    else if(r instanceof InvokeExpr)
      {
	InvokeExpr ie = (InvokeExprr;
      }
    else if(r instanceof NewArrayExpr)
      {
	Type baseType = nae.getBaseType();
	if(baseType instanceof ArrayType)
	  {
	    right = .typeVariable(ArrayType.v(((ArrayTypebaseType).
						      ((ArrayTypebaseType). + 1));
	  }
	else
	  {
	    right = .typeVariable(ArrayType.v(baseType, 1));
	  }
	if()
	  {
	    Value size = nae.getSize();
	    if(size instanceof Local)
	      {
	      }
	  }
      }
    else if(r instanceof NewExpr)
      {
	NewExpr na = (NewExprr;
      }
    else if(r instanceof NewMultiArrayExpr)
      {
	if()
	  {
	    for(int i = 0; i < nmae.getSizeCount(); i++)
	      {
		Value size = nmae.getSize(i);
		if(size instanceof Local)
		  {
		    TypeVariable var = .typeVariable((Localsize);
		    var.addParent(.typeVariable(IntType.v()));
		  }
	      }
	  }
      }
    else if(r instanceof LengthExpr)
      {
	LengthExpr le = (LengthExprr;
	if()
	  {
	    if(le.getOp() instanceof Local)
	      {
	      }
	  }
	right = .typeVariable(IntType.v());
      }
    else if(r instanceof NegExpr)
      {
	NegExpr ne = (NegExprr;
	if(ne.getOp() instanceof Local)
	  {
	    right = .typeVariable((Localne.getOp());
	  }
	else if(ne.getOp() instanceof DoubleConstant)
	  {
	    right = .typeVariable(DoubleType.v());
	  }
	else if(ne.getOp() instanceof FloatConstant)
	  {
	    right = .typeVariable(FloatType.v());
	  }
	else if(ne.getOp() instanceof IntConstant)
	  {
	    right = .typeVariable(IntType.v());
	  }
	else if(ne.getOp() instanceof LongConstant)
	  {
	    right = .typeVariable(LongType.v());
	  }
	else
	  {
	    throw new RuntimeException("Unhandled neg expression operand type: " + ne.getOp().getClass());
	  }
      }
    else if(r instanceof Local)
      {
	right = .typeVariable((Localr);
      }
    else if(r instanceof InstanceFieldRef)
      {
	if()
	  {
	    TypeVariable baseType = .typeVariable((Localref.getBase());
	  }
      }
    else if(r instanceof StaticFieldRef)
      {
      }
    else
      {
	throw new RuntimeException("Unhandled assignment right hand side type: " + r.getClass());
      }
    if(left != null && right != null)
      {
	right.addParent(left);
      }
  }
  public void caseIdentityStmt(IdentityStmt stmt)
  {
    Value l = stmt.getLeftOp();
    Value r = stmt.getRightOp();
    if(l instanceof Local)
      {
	if(!(r instanceof CaughtExceptionRef))
	  {
	    TypeVariable right = .typeVariable(r.getType());
	    right.addParent(left);
	  }
	else
	  {
	    List exceptionTypes = TrapManager.getExceptionTypesOf(stmt);
	    Iterator typeIt = exceptionTypes.iterator();
	    while(typeIt.hasNext())
	      {
		Type t = (TypetypeIt.next();
	      }
	    if()
	      {
		left.addParent(.typeVariable(RefType.v("java.lang.Throwable")));
	      }
	  }
      }
  }
  public void caseEnterMonitorStmt(EnterMonitorStmt stmt)
  {
    if()
      {
	if(stmt.getOp() instanceof Local)
	  {
	    TypeVariable op = .typeVariable((Localstmt.getOp());
	    
	    op.addParent(.typeVariable(RefType.v("java.lang.Object")));
	  }
      }
  }
  public void caseExitMonitorStmt(ExitMonitorStmt stmt)
  {
    if()
      {
	if(stmt.getOp() instanceof Local)
	  {
	    TypeVariable op = .typeVariable((Localstmt.getOp());
	    
	    op.addParent(.typeVariable(RefType.v("java.lang.Object")));
	  }
      }
  }
  public void caseGotoStmt(GotoStmt stmt)
  {
  }
  public void caseIfStmt(IfStmt stmt)
  {
    if()
      {
	BinopExpr expr = cond;
	Value lv = expr.getOp1();
	Value rv = expr.getOp2();
	//******** LEFT ********
	if(lv instanceof Local)
	  {
	    lop = .typeVariable((Locallv);
	  }
	else if(lv instanceof DoubleConstant)
	  {
	    lop = .typeVariable(DoubleType.v());
	  }
	else if(lv instanceof FloatConstant)
	  {
	    lop = .typeVariable(FloatType.v());
	  }
	else if(lv instanceof IntConstant)
	  {
	    lop = .typeVariable(IntType.v());
	  }
	else if(lv instanceof LongConstant)
	  {
	    lop = .typeVariable(LongType.v());
	  }
	else if(lv instanceof NullConstant)
	  {
	    lop = .typeVariable(NullType.v());
	  }
	else if(lv instanceof StringConstant)
	  {
	    lop = .typeVariable(RefType.v("java.lang.String"));
	  }
	else if(lv instanceof ClassConstant)
	  {
	    lop = .typeVariable(RefType.v("java.lang.Class"));
	  }
	else
	  {
	    throw new RuntimeException("Unhandled binary expression left operand type: " + lv.getClass());
	  }
	//******** RIGHT ********
	if(rv instanceof Local)
	  {
	    rop = .typeVariable((Localrv);
	  }
	else if(rv instanceof DoubleConstant)
	  {
	    rop = .typeVariable(DoubleType.v());
	  }
	else if(rv instanceof FloatConstant)
	  {
	    rop = .typeVariable(FloatType.v());
	  }
	else if(rv instanceof IntConstant)
	  {
	    rop = .typeVariable(IntType.v());
	  }
	else if(rv instanceof LongConstant)
	  {
	    rop = .typeVariable(LongType.v());
	  }
	else if(rv instanceof NullConstant)
	  {
	    rop = .typeVariable(NullType.v());
	  }
	else if(rv instanceof StringConstant)
	  {
	    rop = .typeVariable(RefType.v("java.lang.String"));
	  }
	else if(rv instanceof ClassConstant)
	  {
	    rop = .typeVariable(RefType.v("java.lang.Class"));
	  }
	else
	  {
	    throw new RuntimeException("Unhandled binary expression right operand type: " + rv.getClass());
	  }
	rop.addParent(common);
	lop.addParent(common);
      }
  }
  public void caseLookupSwitchStmt(LookupSwitchStmt stmt)
  {
    if()
      {
	Value key = stmt.getKey();
	if(key instanceof Local)
	  {
	  }
      }
  }
  public void caseNopStmt(NopStmt stmt)
  {
  }
  public void caseReturnStmt(ReturnStmt stmt)
  {
    if()
      {
	if(stmt.getOp() instanceof Local)
	  {
	    .typeVariable((Localstmt.getOp()).
	  }
      }
  }
  public void caseReturnVoidStmt(ReturnVoidStmt stmt)
  {
  }
  public void caseTableSwitchStmt(TableSwitchStmt stmt)
  {
    if()
      {
	Value key = stmt.getKey();
	if(key instanceof Local)
	  {
	  }
      }
  }
  public void caseThrowStmt(ThrowStmt stmt)
  {
    if()
      {
	if(stmt.getOp() instanceof Local)
	  {
	    TypeVariable op = .typeVariable((Localstmt.getOp());
	    
	    op.addParent(.typeVariable(RefType.v("java.lang.Throwable")));
	  }
      }
  }
  public void defaultCase(Stmt stmt)
  {
    throw new RuntimeException("Unhandled statement type: " + stmt.getClass());
  }
New to GrepCode? Check out our FAQ X