Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Soot - a J*va Optimization Framework
   * Copyright (C) 2003 Navindra Umanee <navindra@cs.mcgill.ca>
   *
   * 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.toolkits.scalar;
 
 import soot.*;
Utility class used to package a Value and a Unit together.

Author(s):
Navindra Umanee
 
 public class ValueUnitPair extends AbstractValueBox implements UnitBoxEquivTo
 {
     // oub was initially a private inner class.  ended up being a
     // *bad* *bad* idea with endless opportunity for *evil* *evil*
     // pointer bugs.  in the end so much code needed to be copy pasted
     // that using an innerclass to reuse code from AbstractUnitBox was
     // a losing proposition.
     // protected UnitBox oub;
     protected Unit unit;
        
    
Constructs a ValueUnitPair from a Unit object and a Value object.

Parameters:
value some Value
unit some Unit.
 
     public ValueUnitPair(Value valueUnit unit)
     {
         setValue(value);
         setUnit(unit);
     }
 
     public boolean canContainValue(Value value)
     {
 	return true;
     }

    
 
     public void setUnit(Unit unit)
     {
         /* Code copied from AbstractUnitBox */
         
         if(!canContainUnit(unit))
             throw new RuntimeException("Cannot put " + unit + " in this box");
         
         // Remove this from set of back pointers.
         if(this. != null){
             this..removeBoxPointingToThis(this);
         }
 
         // Perform link
         this. = unit;
 
         // Add this to back pointers
         if(this. != null){
             this..addBoxPointingToThis(this);
         }
     }

    
 
     public Unit getUnit()
     {
         return ;
     }

    
 
     public boolean canContainUnit(Unit u)
     {
         return true;
     }

    
 
    public boolean isBranchTarget()
    {
        return true;
    }
    public String toString()
    {
        return "Value = " + getValue() + ", Unit = " + getUnit();
    }
    public void toString(UnitPrinter up
    {
        super.toString(up);
        if(isBranchTarget())
            up.literal(", ");
        else
            up.literal(" #");
        up.startUnitBox(this);
        up.unitRef(isBranchTarget());
        up.endUnitBox(this);
    }
    
    public int hashCode()
    {
        // If you need to change this implementation, please change it
        // in a subclass.  Otherwise, Shimple is likely to break in evil
        // ways.
        return super.hashCode();
    }
    public boolean equals(Object other)
    {
        // If you need to change this implementation, please change it
        // in a subclass.  Otherwise, Shimple is likely to break in evil
        // ways.
        return super.equals(other);
    }
    
    
Two ValueUnitPairs are equivTo iff they hold the same Unit objects and equivalent Value objects within them.

Parameters:
other another ValueUnitPair
Returns:
true if other contains the same objects as this.
    public boolean equivTo(Object other)
    {
        return
            (other instanceof ValueUnitPair) &&
            ((ValueUnitPairother).getValue().equivTo(this.getValue()) &&
            ((ValueUnitPairother).getUnit().equals(getUnit());
    }

    
Non-deterministic hashcode consistent with equivTo() implementation.

Note: If you are concerned about non-determinism, remember that current implementations of equivHashCode() in other parts of Soot are non-deterministic as well (see Constant.java for example).

    public int equivHashCode()
    {
        // this is not deterministic because a Unit's hash code is
        // non-deterministic. 
        return
            (getUnit().hashCode() * 17) +
            (getValue().equivHashCode() * 101);
    }
    
    public Object clone()
    {
        // Note to self: Do not try to "fix" this.  Yes, it should be
        // a shallow copy in order to conform with the rest of Soot.
        // When a body is cloned, the Values are cloned explicitly and
        // replaced, and UnitBoxes are explicitly patched.  See
        // Body.importBodyContentsFrom for details.
        Value cv = Jimple.cloneIfNecessary(getValue());
        Unit cu = getUnit();
        return new ValueUnitPair(cvcu);
    }
New to GrepCode? Check out our FAQ X