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.integer;
  
  import soot.*;
  import soot.jimple.*;
  import java.io.*;
  
  {
    private final TypeResolver resolver;
    private final boolean fix;  // if true, fix constraint violations
    
    private JimpleBody stmtBody;
  
    public ConstraintChecker(TypeResolver resolverboolean fix)
    {
      this. = resolver;
      this. = fix;
    }
  
    public void check(Stmt stmtJimpleBody stmtBodythrows TypeException
    {
      try
        {
  	this. = stmtBody;
  	stmt.apply(this);
        }
      catch(RuntimeTypeException e)
        {
           StringWriter st = new StringWriter();
           PrintWriter pw = new PrintWriter(st);
  	 e.printStackTrace(pw);
  	 pw.close();
           throw new TypeException(st.toString());
        }
    }
  
    private static class RuntimeTypeException extends RuntimeException
    {
      RuntimeTypeException(String message)
      {
        super(message);
      }
    }
  
    static void error(String message)
    {
      throw new RuntimeTypeException(message);
    }
  
    private void handleInvokeExpr(InvokeExpr ieStmt invokestmt)
    {
      if(ie instanceof InterfaceInvokeExpr)
        {
  	SootMethodRef method = invoke.getMethodRef();
  	int count = invoke.getArgCount();
  	
  	for(int i = 0; i < counti++)
  	  {
  	    if(invoke.getArg(iinstanceof Local)
  	      {
  		Local local = (Localinvoke.getArg(i);
  		
  		if(local.getType() instanceof IntegerType)
  		  {
  		    if(!ClassHierarchy.v().typeNode(local.getType()).
  		       hasAncestor_1(ClassHierarchy.v().typeNode(method.parameterType(i))))
  		      {
  			if()
  			  {
  			    invoke.setArg(iinsertCast(localmethod.parameterType(i), invokestmt));
  			  }
  			else
 			  {
 			    error("Type Error(1)");
 			  }
 		      }
 		  }
 	      }
 	  }
       }
     else if(ie instanceof SpecialInvokeExpr)
       {
 	SootMethodRef method = invoke.getMethodRef();
 	int count = invoke.getArgCount();
 	
 	for(int i = 0; i < counti++)
 	  {
 	    if(invoke.getArg(iinstanceof Local)
 	      {
 		Local local = (Localinvoke.getArg(i);
 		
 		if(local.getType() instanceof IntegerType)
 		  {
 		    if(!ClassHierarchy.v().typeNode(local.getType()).
 		       hasAncestor_1(ClassHierarchy.v().typeNode(method.parameterType(i))))
 		      {
 			if()
 			  {
 			    invoke.setArg(iinsertCast(localmethod.parameterType(i), invokestmt));
 			  }
 			else
 			  {
 			    error("Type Error(2)");
 			  }
 		      }
 		  }
 	      }
 	  }
       }
     else if(ie instanceof VirtualInvokeExpr)
       {
 	SootMethodRef method = invoke.getMethodRef();
 	int count = invoke.getArgCount();
 	
 	for(int i = 0; i < counti++)
 	  {
 	    if(invoke.getArg(iinstanceof Local)
 	      {
 		Local local = (Localinvoke.getArg(i);
 		
 		if(local.getType() instanceof IntegerType)
 		  {
 		    if(!ClassHierarchy.v().typeNode(local.getType()).
 		       hasAncestor_1(ClassHierarchy.v().typeNode(method.parameterType(i))))
 		      {
 			if()
 			  {
 			    invoke.setArg(iinsertCast(localmethod.parameterType(i), invokestmt));
 			  }
 			else
 			  {
 			    error("Type Error(3)");
 			  }
 		      }
 		  }
 	      }
 	  }
       }
     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);
 		
 		if(local.getType() instanceof IntegerType)
 		  {
 		    if(!ClassHierarchy.v().typeNode(local.getType()).
 		       hasAncestor_1(ClassHierarchy.v().typeNode(method.parameterType(i))))
 		      {
 			if()
 			  {
 			    invoke.setArg(iinsertCast(localmethod.parameterType(i), invokestmt));
 			  }
 			else
 			  {
 			    error("Type Error(4)");
 			  }
 		      }
 		  }
 	      }
 	  }
       }
     else
       {
 	throw new RuntimeException("Unhandled invoke expression type: " + ie.getClass());
       }
   }
 
   public void caseBreakpointStmt(BreakpointStmt stmt)
   {
     // Do nothing
   }
 
   public void caseInvokeStmt(InvokeStmt stmt)
   {
     handleInvokeExpr(stmt.getInvokeExpr(), stmt);
   }
 
   public void caseAssignStmt(AssignStmt stmt)
   {
     Value l = stmt.getLeftOp();
     Value r = stmt.getRightOp();
 
     TypeNode left = null;
     TypeNode right = null;
 
     //******** LEFT ********
 
     if(l instanceof ArrayRef)
       {
 	ArrayRef ref = (ArrayRefl;
 	Type baset = ((Localref.getBase()).getType();
 	if(!(baset instanceof NullType))
 	{
 	  ArrayType base = (ArrayTypebaset;
 	  Value index = ref.getIndex();
 	
 	  if((base.numDimensions == 1) &&
 	     (base.baseType instanceof IntegerType))
 	    {
 	      left = ClassHierarchy.v().typeNode(base.baseType);
 	    }
 	
 	  if(index instanceof Local)
 	    {
 	      if(!ClassHierarchy.v().typeNode(((Localindex).getType()).hasAncestor_1(ClassHierarchy.v().))
 	        {
 		  if()
 		    {
 		      ref.setIndex(insertCast((Localindex, IntType.v(), stmt));
 		    }
 		  else
 		    {
 		      error("Type Error(5)");
 		    }
 	        }
 	    }
         }
       }
     else if(l instanceof Local)
       {
 	if(((Locall).getType() instanceof IntegerType)
 	  {
 	    left = ClassHierarchy.v().typeNode(((Locall).getType());
 	  }
       }
     else if(l instanceof InstanceFieldRef)
       {
 	
 	if(ref.getField().getType() instanceof IntegerType)
 	  {
 	    left = ClassHierarchy.v().typeNoderef.getField().getType());
 	  }
       }
     else if(l instanceof StaticFieldRef)
       {
 
 	if(ref.getField().getType() instanceof IntegerType)
 	  {
 	    left = ClassHierarchy.v().typeNode(ref.getField().getType());
 	  }
       }
     else
       {
 	throw new RuntimeException("Unhandled assignment left hand side type: " + l.getClass());
       }
 
     //******** RIGHT ********
 
     if(r instanceof ArrayRef)
       {
 	ArrayRef ref = (ArrayRefr;
 	Type baset = ((Localref.getBase()).getType();
 	if(!(baset instanceof NullType))
 	{
 	  ArrayType base = (ArrayTypebaset;
 	  Value index = ref.getIndex();
 	
 	  if((base.numDimensions == 1) &&
 	     (base.baseType instanceof IntegerType))
 	    {
 	      right = ClassHierarchy.v().typeNode(base.baseType);
 	    }
 	
 	  if(index instanceof Local)
 	    {
 	      if(!ClassHierarchy.v().typeNode(((Localindex).getType()).hasAncestor_1(ClassHierarchy.v().))
 	        {
 		  if()
 		    {
 		      ref.setIndex(insertCast((Localindex, IntType.v(), stmt));
 		    }
 		  else
 		    {
 		      error("Type Error(6)");
 		    }
 	        }
 	    }
 	}
       }
     else if(r instanceof DoubleConstant)
       {
       }
     else if(r instanceof FloatConstant)
       {
       }
     else if(r instanceof IntConstant)
       {
 	int value  = ((IntConstantr).;
 	
 	if(value < -32768)
 	  {
 	    right = ClassHierarchy.v().;
 	  }
 	else if(value < -128)
 	  {
 	    right = ClassHierarchy.v().;
 	  }
 	else if(value < 0)
 	  {
 	    right = ClassHierarchy.v().;
 	  }
 	else if(value < 2)
 	  {
 	    right = ClassHierarchy.v().;
 	  }
 	else if(value < 128)
 	  {
 	    right = ClassHierarchy.v().;
 	  }
 	else if(value < 32768)
 	  {
 	    right = ClassHierarchy.v().;
 	  }
 	else if(value < 65536)
 	  {
 	    right = ClassHierarchy.v().;
 	  }
 	else
 	  {
 	    right = ClassHierarchy.v().;
 	  }
       }
     else if(r instanceof LongConstant)
       {
       }
     else if(r instanceof NullConstant)
       {
       }
     else if(r instanceof StringConstant)
       {
       }
     else if(r instanceof ClassConstant)
       {
       }
     else if(r instanceof BinopExpr)
       {
 	//******** BINOP EXPR ********
 	
 	BinopExpr be = (BinopExprr;
 
 	Value lv = be.getOp1();
 	Value rv = be.getOp2();
 	
 	TypeNode lop = null;
 	TypeNode rop = null;
 
 	//******** LEFT ********
 	if(lv instanceof Local)
 	  {
 	    if(((Locallv).getType() instanceof IntegerType)
 	      {
 		lop = ClassHierarchy.v().typeNode(((Locallv).getType());
 	      }
 	  }
 	else if(lv instanceof DoubleConstant)
 	  {
 	  }
 	else if(lv instanceof FloatConstant)
 	  {
 	  }
 	else if(lv instanceof IntConstant)
 	  {
 	    int value  = ((IntConstantlv).;
 	    
 	    if(value < -32768)
 	      {
 		lop = ClassHierarchy.v().;
 	      }
 	    else if(value < -128)
 	      {
 		lop = ClassHierarchy.v().;
 	      }
 	    else if(value < 0)
 	      {
 		lop = ClassHierarchy.v().;
 	      }
 	    else if(value < 2)
 	      {
 		lop = ClassHierarchy.v().;
 	      }
 	    else if(value < 128)
 	      {
 		lop = ClassHierarchy.v().;
 	      }
 	    else if(value < 32768)
 	      {
 		lop = ClassHierarchy.v().;
 	      }
 	    else if(value < 65536)
 	      {
 		lop = ClassHierarchy.v().;
 	      }
 	    else
 	      {
 		lop = ClassHierarchy.v().;
 	      }
 	  }
 	else if(lv instanceof LongConstant)
 	  {
 	  }
 	else if(lv instanceof NullConstant)
 	  {
 	  }
 	else if(lv instanceof StringConstant)
 	  {
 	  }
 	else if(lv instanceof ClassConstant)
 	  {
 	  }
 	else
 	  {
 	    throw new RuntimeException("Unhandled binary expression left operand type: " + lv.getClass());
 	  }
 	
 	//******** RIGHT ********
 	if(rv instanceof Local)
 	  {
 	    if(((Localrv).getType() instanceof IntegerType)
 	      {
 		rop = ClassHierarchy.v().typeNode(((Localrv).getType());
 	      }
 	  }
 	else if(rv instanceof DoubleConstant)
 	  {
 	  }
 	else if(rv instanceof FloatConstant)
 	  {
 	  }
 	else if(rv instanceof IntConstant)
 	  {
 	    int value  = ((IntConstantrv).;
 	    
 	    if(value < -32768)
 	      {
 		rop = ClassHierarchy.v().;
 	      }
 	    else if(value < -128)
 	      {
 		rop = ClassHierarchy.v().;
 	      }
 	    else if(value < 0)
 	      {
 		rop = ClassHierarchy.v().;
 	      }
 	    else if(value < 2)
 	      {
 		rop = ClassHierarchy.v().;
 	      }
 	    else if(value < 128)
 	      {
 		rop = ClassHierarchy.v().;
 	      }
 	    else if(value < 32768)
 	      {
 		rop = ClassHierarchy.v().;
 	      }
 	    else if(value < 65536)
 	      {
 		rop = ClassHierarchy.v().;
 	      }
 	    else
 	      {
 		rop = ClassHierarchy.v().;
 	      }
 	  }
 	else if(rv instanceof LongConstant)
 	  {
 	  }
 	else if(rv instanceof NullConstant)
 	  {
 	  }
 	else if(rv instanceof StringConstant)
 	  {
 	  }
 	else if(rv instanceof ClassConstant)
 	  {
 	  }
 	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))
 	  {
 	    if(lop != null && rop != null)
 	      {
 		if(!lop.hasAncestor_1(ClassHierarchy.v().))
 		  {
 		    if()
 		      {
 			be.setOp1(insertCast(be.getOp1(), getTypeForCast(lop), IntType.v(), stmt));
 		      }
 		    else
 		      {
 			error("Type Error(7)");
 		      }
 		  }
 
 		if(!rop.hasAncestor_1(ClassHierarchy.v().))
 		  {
 		    if()
 		      {
 			be.setOp2(insertCast(be.getOp2(), getTypeForCast(rop), IntType.v(), stmt));
 		      }
 		    else
 		      {
 			error("Type Error(8)");
 		      }
 		  }
 	      }
 	    
 	    right = ClassHierarchy.v().;
 	  }
 	else if((be instanceof AndExpr) ||
 		(be instanceof OrExpr) ||
 		(be instanceof XorExpr))
 	  {
 	    if(lop != null && rop != null)
 	      {
 		TypeNode lca = lop.lca_1(rop);
 		
 		if(lca == ClassHierarchy.v().)
 		  {
 		    if()
 		      {
 			if(!lop.hasAncestor_1(ClassHierarchy.v().))
 			  {
 			    be.setOp1(insertCast(be.getOp1(), getTypeForCast(lop), getTypeForCast(rop), stmt));
 			    lca = rop;
 			  }
 			
 			if(!rop.hasAncestor_1(ClassHierarchy.v().))
 			  {
 			    be.setOp2(insertCast(be.getOp2(), getTypeForCast(rop), getTypeForCast(lop), stmt));
 			    lca = lop;			
 			  }
 		      }
 		    else
 		      {
 			error("Type Error(11)");
 		      }
 		  }
 		
 		right = lca;
 	      }
 	  }
 	else if(be instanceof ShlExpr)
 	  {
 	    if(lop != null)
 	      {
 		if(!lop.hasAncestor_1(ClassHierarchy.v().))
 		  {
 		    if()
 		      {
 			be.setOp1(insertCast(be.getOp1(), getTypeForCast(lop), IntType.v(), stmt));
 		      }
 		    else
 		      {
 			error("Type Error(9)");
 		      }
 		  }
 	      }
 		
 	    if(!rop.hasAncestor_1(ClassHierarchy.v().))
 	      {
 		if()
 		  {
 		    be.setOp2(insertCast(be.getOp2(), getTypeForCast(rop), IntType.v(), stmt));
 		  }
 		else
 		  {
 		    error("Type Error(10)");
 		  }
 	      }
 	    
 	    right = (lop == null) ? null : ClassHierarchy.v().;
 	  }
 	else if((be instanceof ShrExpr) ||
 		(be instanceof UshrExpr))
 	  {
 	    if(lop != null)
 	      {
 		if(!lop.hasAncestor_1(ClassHierarchy.v().))
 		  {
 		    if()
 		      {
 			be.setOp1(insertCast(be.getOp1(), getTypeForCast(lop), ByteType.v(), stmt));
 			lop = ClassHierarchy.v().;
 		      }
 		    else
 		      {
 			error("Type Error(9)");
 		      }
 		  }
 	      }
 		
 	    if(!rop.hasAncestor_1(ClassHierarchy.v().))
 	      {
 		if()
 		  {
 		    be.setOp2(insertCast(be.getOp2(), getTypeForCast(rop), IntType.v(), stmt));
 		  }
 		else
 		  {
 		    error("Type Error(10)");
 		  }
 	      }
 
 	    right = lop;
 	  }
 	else if((be instanceof CmpExpr) ||
 		(be instanceof CmpgExpr) ||
 		(be instanceof CmplExpr))
 	  {
 	    right = ClassHierarchy.v().;
 	  }
 	else if((be instanceof EqExpr) ||
 		(be instanceof GeExpr) ||
 		(be instanceof GtExpr) ||
 		(be instanceof LeExpr) ||
 		(be instanceof LtExpr) ||
 		(be instanceof NeExpr))
 	  {
 	    TypeNode lca = lop.lca_1(rop);
 	    
 	    if(lca == ClassHierarchy.v().)
 	      {
 		if()
 		  {
 		    if(!lop.hasAncestor_1(ClassHierarchy.v().))
 		      {
 			be.setOp1(insertCast(be.getOp1(), getTypeForCast(lop), getTypeForCast(rop), stmt));
 		      }
 		    
 		    if(!rop.hasAncestor_1(ClassHierarchy.v().))
 		      {
 			be.setOp2(insertCast(be.getOp2(), getTypeForCast(rop), getTypeForCast(lop), stmt));
 		      }
 		  }
 		else
 		  {
 		    error("Type Error(11)");
 		  }
 	      }
 	    
 	    right = ClassHierarchy.v().;
 	  }
 	else
 	  {
 	    throw new RuntimeException("Unhandled binary expression type: " + be.getClass());
 	  }
       }
     else if(r instanceof CastExpr)
       {
 	CastExpr ce = (CastExprr;
 
 	if(ce.getCastType() instanceof IntegerType)
 	  {
 	    right = ClassHierarchy.v().typeNode(ce.getCastType());
 	  }
       }
     else if(r instanceof InstanceOfExpr)
       {
 	right = ClassHierarchy.v().;
       }
     else if(r instanceof InvokeExpr)
       {
 	InvokeExpr ie = (InvokeExprr;
 
 	handleInvokeExpr(iestmt);
 	
 	if(ie.getMethodRef().returnType() instanceof IntegerType)
 	  {
 	    right = ClassHierarchy.v().typeNode(ie.getMethodRef().returnType());
 	  }
       }
     else if(r instanceof NewArrayExpr)
       {
 	NewArrayExpr nae = (NewArrayExprr;
 	Value size = nae.getSize();
 
 	if(size instanceof Local)
 	  {
 	    if(!ClassHierarchy.v().typeNode(((Localsize).getType()).
 	       hasAncestor_1(ClassHierarchy.v().))
 	      {
 		if()
 		  {
 		    nae.setSize(insertCast((Localsize, IntType.v(), stmt));
 		  }
 		else
 		  {
 		    error("Type Error(12)");
 		  }
 	      }
 	  }
       }
     else if(r instanceof NewExpr)
       {
       }
     else if(r instanceof NewMultiArrayExpr)
       {
 
 	for(int i = 0; i < nmae.getSizeCount(); i++)
 	  {
 	    Value size = nmae.getSize(i);
 
 	    if(size instanceof Local)
 	      {
 		if(!ClassHierarchy.v().typeNode(((Localsize).getType()).
 		   hasAncestor_1(ClassHierarchy.v().))
 		  {
 		    if()
 		      {
 			nmae.setSize(iinsertCast((Localsize, IntType.v(), stmt));
 		      }
 		    else
 		      {
 			error("Type Error(13)");
 		      }
 		  }
 	      }
 	  }
       }
     else if(r instanceof LengthExpr)
       {
 	right = ClassHierarchy.v().;
       }
     else if(r instanceof NegExpr)
       {
 	NegExpr ne = (NegExprr;
 
 	if(ne.getOp() instanceof Local)
 	  {
 	    Local local = (Localne.getOp();
 
 	    if(local.getType() instanceof IntegerType)
 	      {
 		TypeNode ltype = ClassHierarchy.v().typeNode(local.getType());
 		if(!ltype.hasAncestor_1(ClassHierarchy.v().))
 		  {
 		    if()
 		      {
 			ne.setOp(insertCast(local, IntType.v(), stmt));
 			ltype = ClassHierarchy.v().;
 		      }
 		    else
 		      {
 			error("Type Error(14)");
 		      }
 		  }
 
 		right = (ltype == ClassHierarchy.v().) ? ClassHierarchy.v(). : ltype;
 	      }
 	  }
 	else if(ne.getOp() instanceof DoubleConstant)
 	  {
 	  }
 	else if(ne.getOp() instanceof FloatConstant)
 	  {
 	  }
 	else if(ne.getOp() instanceof IntConstant)
 	  {
 	    right = ClassHierarchy.v().;
 	  }
 	else if(ne.getOp() instanceof LongConstant)
 	  {
 	  }
 	else
 	  {
 	    throw new RuntimeException("Unhandled neg expression operand type: " + ne.getOp().getClass());
 	  }
       }
     else if(r instanceof Local)
       {
 	Local local = (Localr;
 	
 	if(local.getType() instanceof IntegerType)
 	  {
 	    right = ClassHierarchy.v().typeNode(local.getType());
 	  }
       }
     else if(r instanceof InstanceFieldRef)
       {
 
 	if(ref.getField().getType() instanceof IntegerType)
 	  {
 	    right = ClassHierarchy.v().typeNode(ref.getField().getType());
 	  }
       }
     else if(r instanceof StaticFieldRef)
       {
 
 	if(ref.getField().getType() instanceof IntegerType)
 	  {
 	    right = ClassHierarchy.v().typeNode(ref.getField().getType());
 	  }
       }
     else
       {
 	throw new RuntimeException("Unhandled assignment right hand side type: " + r.getClass());
       }
 
     if(left != null && right != null)
       {
 	if(!right.hasAncestor_1(left))
 	  {
 	    if()
 	      {
 		stmt.setRightOp(insertCast(stmt.getRightOp(), getTypeForCast(right), getTypeForCast(left), stmt));
 	      }
 	    else
 	      {
 		error("Type Error(15)");
 	      }
 	  }
       }
   }
 
   static Type getTypeForCast(TypeNode node)
       // This method is a local kludge, for avoiding NullPointerExceptions
       // when a R0_1, R0_127, or R0_32767 node is used in a type
       // cast. A more elegant solution would work with the TypeNode 
       // type definition itself, but that would require a more thorough
       // knowledge of the typing system than the kludger posesses.
   {
     if (node.type() == null
       {
 	if (node == ClassHierarchy.v().
 	  {
 	    return BooleanType.v();
 	  }
 	else if (node == ClassHierarchy.v().
 	  { 
 	    return ByteType.v();
 	  }
 	else if (node == ClassHierarchy.v().)
 	  {
 	    return ShortType.v();
 	  }
 	// Perhaps we should throw an exception here, since I don't think
 	// there should be any other cases where node.type() is null. 
 	// In case that supposition is incorrect, though, we'll just
 	// go on to return the null, and let the callers worry about it.
       }
     return node.type();
   }
 
   public void caseIdentityStmt(IdentityStmt stmt)
   {
     Value l = stmt.getLeftOp();
     Value r = stmt.getRightOp();
 
     if(l instanceof Local)
       {
 	if(((Locall).getType() instanceof IntegerType)
 	  {
 	    TypeNode left = ClassHierarchy.v().typeNode((((Locall).getType()));
 	    TypeNode right = ClassHierarchy.v().typeNode(r.getType());
 
 	    if(!right.hasAncestor_1(left))
 	      {
 		if()
 		  {
 		    ((soot.jimple.internal.JIdentityStmtstmt).setLeftOp(insertCastAfter((LocallgetTypeForCast(left), getTypeForCast(right), stmt));
 		  }
 		else
 		  {
 		    error("Type Error(16)");
 		  }
 	      }
 	  }
       }
   }
 
   public void caseEnterMonitorStmt(EnterMonitorStmt stmt)
   {
   }
 
   public void caseExitMonitorStmt(ExitMonitorStmt stmt)
   {
   }
 
   public void caseGotoStmt(GotoStmt stmt)
   {
   }
 
   public void caseIfStmt(IfStmt stmt)
   {
     ConditionExpr cond = (ConditionExprstmt.getCondition();
     
     BinopExpr expr = cond;
     Value lv = expr.getOp1();
     Value rv = expr.getOp2();
     
     TypeNode lop = null;
     TypeNode rop = null;
     
     //******** LEFT ********
     if(lv instanceof Local)
       {
 	if(((Locallv).getType() instanceof IntegerType)
 	  {
 	    lop = ClassHierarchy.v().typeNode(((Locallv).getType());
 	  }
       }
     else if(lv instanceof DoubleConstant)
       {
       }
     else if(lv instanceof FloatConstant)
       {
       }
     else if(lv instanceof IntConstant)
       {
 	int value  = ((IntConstantlv).;
 	    
 	if(value < -32768)
 	  {
 	    lop = ClassHierarchy.v().;
 	  }
 	else if(value < -128)
 	  {
 	    lop = ClassHierarchy.v().;
 	  }
 	else if(value < 0)
 	  {
 	    lop = ClassHierarchy.v().;
 	  }
 	else if(value < 2)
 	  {
 	    lop = ClassHierarchy.v().;
 	  }
 	else if(value < 128)
 	  {
 		lop = ClassHierarchy.v().;
 	  }
 	else if(value < 32768)
 	  {
 	    lop = ClassHierarchy.v().;
 	  }
 	else if(value < 65536)
 	  {
 	    lop = ClassHierarchy.v().;
 	  }
 	else
 	  {
 	    lop = ClassHierarchy.v().;
 	  }
       }
     else if(lv instanceof LongConstant)
       {
       }
     else if(lv instanceof NullConstant)
       {
      }
    else if(lv instanceof StringConstant)
      {
      }
    else if(lv instanceof ClassConstant)
      {
      }
    else
      {
	throw new RuntimeException("Unhandled binary expression left operand type: " + lv.getClass());
      }
    
    //******** RIGHT ********
    if(rv instanceof Local)
      {
	if(((Localrv).getType() instanceof IntegerType)
	  {
	    rop = ClassHierarchy.v().typeNode(((Localrv).getType());
	  }
      }
    else if(rv instanceof DoubleConstant)
      {
      }
    else if(rv instanceof FloatConstant)
      {
      }
    else if(rv instanceof IntConstant)
      {
	int value  = ((IntConstantrv).;
	if(value < -32768)
	  {
	    rop = ClassHierarchy.v().;
	  }
	else if(value < -128)
	  {
	    rop = ClassHierarchy.v().;
	  }
	else if(value < 0)
	  {
	    rop = ClassHierarchy.v().;
	  }
	else if(value < 2)
	  {
	    rop = ClassHierarchy.v().;
	  }
	else if(value < 128)
	  {
	    rop = ClassHierarchy.v().;
	  }
	else if(value < 32768)
	  {
	    rop = ClassHierarchy.v().;
	  }
	else if(value < 65536)
	  {
	    rop = ClassHierarchy.v().;
	  }
	else
	  {
	    rop = ClassHierarchy.v().;
	  }
      }
    else if(rv instanceof LongConstant)
      {
      }
    else if(rv instanceof NullConstant)
      {
      }
    else if(rv instanceof StringConstant)
      {
      }
    else if(rv instanceof ClassConstant)
      {
      }
    else
      {
	throw new RuntimeException("Unhandled binary expression right operand type: " + rv.getClass());
      }
    
    if(lop != null && rop != null)
      {
	if(lop.lca_1(rop) == ClassHierarchy.v().)
	  {
	    if()
	      {
		if(!lop.hasAncestor_1(ClassHierarchy.v().))
		  {
		    expr.setOp1(insertCast(expr.getOp1(), getTypeForCast(lop), getTypeForCast(rop), stmt));
		  }
		if(!rop.hasAncestor_1(ClassHierarchy.v().))
		  {
		    expr.setOp2(insertCast(expr.getOp2(), getTypeForCast(rop), getTypeForCast(lop), stmt));
		  }
	      }
	    else
	      {
		error("Type Error(17)");
	      }
	  }
      }
  }
  {
    Value key = stmt.getKey();
    
    if(key instanceof Local)
      {
	if(!ClassHierarchy.v().typeNode(((Localkey).getType()).
	   hasAncestor_1(ClassHierarchy.v().))
	  {
	    if()
	      {
		stmt.setKey(insertCast((Localkey, IntType.v(), stmt));
	      }
	    else
	      {
		error("Type Error(18)");
	      }
	  }
      }
  }
  public void caseNopStmt(NopStmt stmt)
  {
  }
  public void caseReturnStmt(ReturnStmt stmt)
  {
    if(stmt.getOp() instanceof Local)
      {
	if(((Localstmt.getOp()).getType() instanceof IntegerType)
	  {
	    if(!ClassHierarchy.v().typeNode(((Localstmt.getOp()).getType()).
	       hasAncestor_1(ClassHierarchy.v().typeNode(.getMethod().getReturnType())))
	      {
		if()
		  {
		    stmt.setOp(insertCast((Localstmt.getOp(), .getMethod().getReturnType(), stmt));
		  }
		else
		  {
		    error("Type Error(19)");
		  }
	      }
	  }
      }
  }
  public void caseReturnVoidStmt(ReturnVoidStmt stmt)
  {
  }
  public void caseTableSwitchStmt(TableSwitchStmt stmt)
  {
    Value key = stmt.getKey();
    
    if(key instanceof Local)
      {
	if(!ClassHierarchy.v().typeNode(((Localkey).getType()).
	   hasAncestor_1(ClassHierarchy.v().))
	  {
	    if()
	      {
		stmt.setKey(insertCast((Localkey, IntType.