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.util.*;
 import java.util.*;

Each instance of this class represents one type in the class hierarchy (or basic types).
 
 class TypeNode
 {
   private static final boolean DEBUG = false;
 
   private final int id;
   private final Type type;
   private final ClassHierarchy hierarchy;
   
   private TypeNode parentClass;
   private TypeNode element;
   private TypeNode array;
 
   private List parents = .;
   private final BitVector ancestors = new BitVector(0);
   private final BitVector descendants = new BitVector(0);
 	
   public TypeNode(int idType typeClassHierarchy hierarchy)
   {
     if(type == null || hierarchy == null)
       {
 	throw new InternalTypingException();
       }
       
     if(!((type instanceof PrimType) || (type instanceof RefType) || 
 	 (type instanceof ArrayType) || (type instanceof NullType)))
       {
 	G.v()..println("Unhandled type: " + type);
 	throw new InternalTypingException();
       }
 
     this. = id;
     this. = type;
     this. = hierarchy;
 
     if()
       {
 	G.v()..println("creating node " + this);
       }
   }
   
   public TypeNode(int idRefType typeClassHierarchy hierarchy)
   {
     this(id, (Typetypehierarchy);
 	
     {    
       SootClass sClass = type.getSootClass();
       ifsClass == null ) throw new RuntimeException"Oops, forgot to load "+type );
       if(sClass.isPhantomClass()) throw new RuntimeException("Jimplification requires "+sClass+", but it is a phantom ref.");
       List plist = new LinkedList();
       
       if(sClass.hasSuperclass() && 
 	 !sClass.getName().equals("java.lang.Object"))
 	{
 	  TypeNode parent = hierarchy.typeNode(RefType.v(sClass.getSuperclass().getName()));
 	  plist.add(parent);
 	   = parent;
 	}
 
       for(Iterator i = sClass.getInterfaces().iterator(); i.hasNext();)
 	{
 	  TypeNode parent = hierarchy.typeNode(RefType.v(((SootClassi.next()).getName()));
 	  plist.add(parent);
 	}
       = Collections.unmodifiableList(plist);
    }
	    
    .set(hierarchy.NULL.id);
    hierarchy.NULL.ancestors.set(id);
    forIterator parentIt = .iterator(); parentIt.hasNext(); ) {
        final TypeNode parent = (TypeNodeparentIt.next();
	.set(parent.id);
	.or(parent.ancestors);
	parent.fixDescendants(id);
      }
  }
  public TypeNode(int idArrayType typeClassHierarchy hierarchy)
  {
    this(id, (Typetypehierarchy);
    if(type.numDimensions < 1)
      {
      }
    if(type.numDimensions == 1)
      {
	 = hierarchy.typeNode(type.baseType);
      }
    else
      {
	 = hierarchy.typeNode(ArrayType.v(type.baseTypetype.numDimensions - 1));
      }
    if( != hierarchy.INT)
      {
	if(. != null)
	  {
	    throw new InternalTypingException();
	  }
	. = this;
      }
    
    {
      List plist = new LinkedList();
      if(type.baseType instanceof RefType)
	{
	  RefType baseType = (RefTypetype.baseType;
	  SootClass sClass = baseType.getSootClass();
	  if(sClass.hasSuperclass() && !sClass.getName().equals("java.lang.Object"))
	    {
	      TypeNode parent = hierarchy.typeNode(ArrayType.v(RefType.v(sClass.getSuperclass().getName()), type.numDimensions));
	      plist.add(parent);
	       = parent;
	    }
	  else if(type.numDimensions == 1)
	    {
	      plist.add(hierarchy.OBJECT);
	      // hack for J2ME library, reported by Stephen Cheng
	      if (!Options.v().j2me()) {
		plist.add(hierarchy.CLONEABLE);
		plist.add(hierarchy.SERIALIZABLE);
	      }
	       = hierarchy.OBJECT;
	    }
	  else
	    {
	      plist.add(hierarchy.typeNode(ArrayType.v(hierarchy.OBJECT.type(), type.numDimensions - 1)));
	      // hack for J2ME library, reported by Stephen Cheng
	      if (!Options.v().j2me()) {
		plist.add(hierarchy.typeNode(ArrayType.v(hierarchy.CLONEABLE.type(), type.numDimensions - 1)));
		plist.add(hierarchy.typeNode(ArrayType.v(hierarchy.SERIALIZABLE.type(), type.numDimensions - 1)));
	      }
	       = hierarchy.typeNode(ArrayType.v(hierarchy.OBJECT.type(), type.numDimensions - 1));
	    }
	  for(Iterator i = sClass.getInterfaces().iterator(); i.hasNext(); )
	    {
	      TypeNode parent = hierarchy.typeNode(ArrayType.v(RefType.v(((SootClassi.next()).getName()), type.numDimensions));
	      plist.add(parent);
	    }
	}
      else if(type.numDimensions == 1)
	{
	  plist.add(hierarchy.OBJECT);
	  // hack for J2ME library, reported by Stephen Cheng
	  if (!Options.v().j2me()) {
	    plist.add(hierarchy.CLONEABLE);
	    plist.add(hierarchy.SERIALIZABLE);
	  }
	   = hierarchy.OBJECT;
	}
      else
	{
	  plist.add(hierarchy.typeNode(ArrayType.v(hierarchy.OBJECT.type(), type.numDimensions - 1)));
	  // hack for J2ME library, reported by Stephen Cheng
	  if (!Options.v().j2me()) {
	    plist.add(hierarchy.typeNode(ArrayType.v(hierarchy.CLONEABLE.type(), type.numDimensions - 1)));
	    plist.add(hierarchy.typeNode(ArrayType.v(hierarchy.SERIALIZABLE.type(), type.numDimensions - 1)));
	  }
	   = hierarchy.typeNode(ArrayType.v(hierarchy.OBJECT.type(), type.numDimensions - 1));
	}
      	    
       = Collections.unmodifiableList(plist);
    }		    
    .set(hierarchy.NULL.id);
    hierarchy.NULL.ancestors.set(id);
    forIterator parentIt = .iterator(); parentIt.hasNext(); ) {
        final TypeNode parent = (TypeNodeparentIt.next();
	.set(parent.id);
	.or(parent.ancestors);
	parent.fixDescendants(id);
      }
  }

  
Adds the given node to the list of descendants of this node and its ancestors.
  private void fixDescendants(int id)
  {
    if(.get(id))
      {
	return;
      }
    forIterator parentIt = .iterator(); parentIt.hasNext(); ) {
        final TypeNode parent = (TypeNodeparentIt.next();
	parent.fixDescendants(id);
      }
    .set(id);
  }

  
Returns the unique id of this type node.
  public int id()
  {
    return ;
  }

  
Returns the type represented by this type node.
  public Type type()
  {
    return ;
  }
  public boolean hasAncestor(TypeNode typeNode)
  {
    return .get(typeNode.id);
  }
  public boolean hasAncestorOrSelf(TypeNode typeNode)
  {
    if(typeNode == this)
      return true;
    return .get(typeNode.id);
  }
  public boolean hasDescendant(TypeNode typeNode)
  {
    return .get(typeNode.id);
  }
  public boolean hasDescendantOrSelf(TypeNode typeNode)
  {
    if(typeNode == this)
      return true;
    return .get(typeNode.id);
  }
  public List parents()
  {
    return ;
  }
  public TypeNode parentClass()
  {
    return ;
  }
  public String toString()
  {
    return .toString()+ "(" +  + ")";
  }
  public TypeNode lca(TypeNode typethrows TypeException
  {
    if(type == null)
      {
      }
    if(type == this)
      {
	return this;
      }
    if(hasAncestor(type))
      {
	return type;
      }
    if(hasDescendant(type))
      {
	return this;
      }
    do
      {
	type = type.parentClass;
	if(type == null)
	  {
	    try
	      {
		TypeVariable.error("Type Error(12)");
	      }
	    catch(TypeException e)
	      {
                if(e.printStackTrace();
		throw e;
	      }
	  }
      }
    while(!hasAncestor(type));
    return type;
  }
  public TypeNode lcaIfUnique(TypeNode typethrows TypeException
  {
    TypeNode initial = type;
    if(type == null)
      {
      }
    if(type == this)
      {
	return this;
      }
    if(hasAncestor(type))
      {
	return type;
      }
    if(hasDescendant(type))
      {
	return this;
      }
    do
      {
	if(type.parents.size() == 1)
	  {
	    type = (TypeNodetype.parents.get(0);
	  }
	else
	  {
	    if()
	      {
		G.v()..println("lca " + initial + " (" + type + ") & " + this + " =");
		for(Iterator i = type.parents.iterator(); i.hasNext(); )
		  {
		    G.v()..println("  " + i.next());
		  }
	      }
	    return null;
	  }
      }
    while(!hasAncestor(type));
    return type;
  }
  public boolean hasElement()
  {
    return  != null;
  }
  public TypeNode element()
  {
    if( == null)
      {
      }
    
    return ;
  }
  public TypeNode array()
  {
    if( != null)
      {
 	return ;
      }
    if( instanceof ArrayType)
      {
	ArrayType atype = (ArrayType;
	 = .typeNode(ArrayType.v(atype.baseTypeatype.numDimensions + 1));
	return ;
      }
    if( instanceof PrimType ||  instanceof RefType)
      {
	 = .typeNode(ArrayType.v(, 1));
	return ;
      }
    throw new InternalTypingException();
  }
  public boolean isNull()
  {
    if( instanceof NullType)
      {
	return true;
      }
    return false;
  }
  public boolean isClass()
  {
    if( instanceof ArrayType ||
        instanceof NullType ||
       ( instanceof RefType &&
      {
	return true;
      }
    return false;
  }
  public boolean isClassOrInterface()
  {
    if( instanceof ArrayType ||
        instanceof NullType ||
        instanceof RefType)
      {
	return true;
      }
    return false;
  }
  public boolean isArray()
  {
    if( instanceof ArrayType ||
        instanceof NullType)
      {
	return true;
      }
    return false;
  }
New to GrepCode? Check out our FAQ X