classentry.java

来自「This is a resource based on j2me embedde」· Java 代码 · 共 586 行 · 第 1/2 页

/*
 * @(#)ClassEntry.java	1.27 06/10/10
 *
 * Copyright  1990-2008 Sun Microsystems, Inc. All Rights Reserved.  
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER  
 *   
 * This program is free software; you can redistribute it and/or  
 * modify it under the terms of the GNU General Public License version  
 * 2 only, as published by the Free Software Foundation.   
 *   
 * This program 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  
 * General Public License version 2 for more details (a copy is  
 * included at /legal/license.txt).   
 *   
 * You should have received a copy of the GNU General Public License  
 * version 2 along with this work; if not, write to the Free Software  
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  
 * 02110-1301 USA   
 *   
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa  
 * Clara, CA 95054 or visit www.sun.com if you need additional  
 * information or have any questions. 
 *
 */

package dependenceAnalyzer;
import util.*;
import java.util.*;
import components.*;
import consts.Const;

/*
 * Class ClassEntry is for use with Member-level dependence analysis.
 * It is not only a part of the dependence relations but also
 * a container for MemberDependenceNodes, and thus
 * a part of the naming mechanism.
 *
 * This is where class members are parsed, and thus
 * their dependences discovered and exposed.
 */

public class ClassEntry extends DependenceNode implements MemberArcTypes {
    /*
     * public parts.
     */
    public boolean signatureFlag = false;
    public ClassEntry	superClass(){ return superClassEntry; }
    public Enumeration  subclasses(){
	return (subclassSet == null ) ? EmptyEnumeration.instance : subclassSet.elements();
    }
    public Enumeration	members(){
	return (memberSet == null ) ? EmptyEnumeration.instance : memberSet.elements();
    }
    public Enumeration interfaces(){
	return (interfaceSet == null ) ? EmptyEnumeration.instance : interfaceSet.elements();
    }

    public MemberDependenceNode lookupMember( MemberName mn ){
	if ( memberSet == null ) return null;
	return (MemberDependenceNode)(memberSet.get( mn ));
    }

    private MemberName t = new MemberName( this, "" );
    
    public  MemberDependenceNode lookupMember( String mname ){
	// ... won't work multithreaded!...
	t.name = mname.intern();
	return lookupMember( t );
    }

    public MemberDependenceNode lookupAddMember( MemberName mn, int mflags ){
	MemberDependenceNode mnode = lookupMember( mn );
	if ( mnode == null ){
	    mnode = new MemberDependenceNode( mn, mflags );
	    if ( memberSet == null )
		memberSet = new Hashtable();
	    memberSet.put( mn, mnode );
	} else if ( mflags != 0 ){
	    mnode.flags = mflags;
	}
	if ( (this.flags&EXCLUDED) != 0 ){
	    // class is excluded, and so are all members.
	    mnode.flags |= MemberDependenceNode.EXCLUDED;
	}

	return mnode;
    }

    public ClassEntry( String name ){
	super( name );
	className = name;
	nodeState = UNANALYZED;
    }

    public boolean analyzeClass( ClassDictionary cd, boolean f ){
	signatureFlag = f;	
	return (analyzeClass(cd));
    }

    public boolean analyzeClass( ClassDictionary cd ){
	if ( nodeState != UNANALYZED ) return(nodeState!=ERROR); // already done.
	nodeState = ANALYZED; // do this early to prevent excess recursion
	cdict = cd; // share the dictionary with the rest of the code.

	ClassInfo ci = cdict.findClassInfo( className );
	if ( ci == null ){
	    // cannot find class info to analyze.
	    // this is not good.
	    nodeState = ERROR;
	} else {
	    nodeState = parseClassInfo( ci );
	}
	return (nodeState!=ERROR);
    }

    /*
     * A class which is marked as an interface does not have to be
     * a Java TM Interface. It merely has to define a contract between
     * two software subsystems. java.applet.Applet is a good example of
     * an interface.
     * An interface is always EXCLUDED.
     * An interface has additional, imputed, members, which
     * are inhereted from superclasses and interfaces, and which
     * form part of the contract. makeInterface creates these after
     * inspecting all superclasses and Java interfaces. This is so that
     * our override-based dependence analysis works.
     * makeInterface returns true on success, false on any adversary
     * Adversary includes:
     *	inability to find class file
     *  class is not EXCLUDED
     *  inability to find superclasses or interfaces
     */
    public boolean makeInterface( ClassDictionary cd ){
	cdict = cd;
	if ( nodeState == UNANALYZED ) 
	    analyzeClass( cd );
	if ( nodeState == ERROR )
	    return false;
	if ( ( flags & EXCLUDED ) == 0 ) return false;
	if ( ( flags & DEFINES_INTERFACE ) != 0 ) return true; // done!
	if ( ! imputeMembers( superClassEntry )) return false;
	if ( interfaceSet != null ){
	    Enumeration ilist = interfaceSet.elements();
	    while ( ilist.hasMoreElements() ){
		if ( ! imputeMembers( (ClassEntry)(ilist.nextElement()) ) )
		    return false;
	    }
	}
	flags |= DEFINES_INTERFACE;
	return true;
    }

    /*
     * Flags. This is pretty much up to the user, except for this one
     * which will govern how things work.
     */
    public static final int EXCLUDED		= MemberDependenceNode.EXCLUDED;
    public static final int DEFINES_INTERFACE	= 2;
    public static final int HAS_OVERRIDING	= 4;


    /*
     * Implementation parts.
     */
    private String	className;
    private ClassEntry	superClassEntry;
    private Vector	subclassSet;
    private Dictionary	memberSet;
    private Vector	interfaceSet = new Vector();

    // 
    // I feel rather silly having this here, as there is
    // no requirement that a ClassEntry be associated with only
    // one dictionary. But the fact is, this variable is
    // referenced in many many places in the analysis routines,
    // and I'd otherwise have to keep passing it around...
    private ClassDictionary cdict;

    private int
    parseClassInfo( ClassInfo ci ){
	//
	// This class cannot be understood without
	// first understanding its super class
	//
	int resultState = ANALYZED;

	if ( ci.superClass != null ){
	    ClassEntry sup =  cdict.lookupAdd( ci.superClass.name.string );
	    if ( sup.nodeState == UNANALYZED )
		sup.analyzeClass( cdict ); // recurse.
	    if ( sup.nodeState != ERROR ){
		superClassEntry = sup;
		sup.addSubclass( this );
	    }
	}

	// interfaces, if any.
	if ( ci.interfaces != null ){
	    for ( int i = 0; i < ci.interfaces.length; i++ ){
		ClassEntry sup =  cdict.lookupAdd( ci.interfaces[i].name.string );
		interfaceSet.addElement( sup );
		sup.addSubclass( this );
		if ( sup.nodeState == UNANALYZED )
		    sup.analyzeClass( cdict ); // recurse.
	    }
	}

	// Take Care the Inner class as well.
        if ( ci.classAttributes != null ){
            for ( int i = 0; i < ci.classAttributes.length; i++ ){
		if (ci.classAttributes[i].name.string.equals("InnerClasses")) {
		    for (int j = 0; j < ci.innerClassAttr.getInnerClassCount(); 
                                                                         j++) {
		    String name = ci.innerClassAttr.getFullName(j);
		    if (name.equals("ICA-ReferingToSelf"))
			continue;

                    ClassEntry inner =  cdict.lookupAdd( name );
                    if ( inner.nodeState == UNANALYZED )
			// if -signatureFlag is set, get api dependency as well.
                        inner.analyzeClass( cdict, signatureFlag); // recurse.
		    }
		}
	    }
        }

	MemberDependenceNode mnode;

	// all the methods.
	if ( ci.methods != null ){
	    for ( int i = 0; i < ci.methods.length; i++ ){
		mnode = overrideAnalysis( parseMethodInfo( ci.methods[i] ) );
		if ( mnode == null ){
		    resultState = ERROR; // bad news.
		} else {
		    mnode.nodeState = DependenceNode.ANALYZED;
		}
	    }
	}

	// and the fields.
	if ( ci.fields != null ){
	    for ( int i = 0; i < ci.fields.length; i++ ){
		mnode = parseFieldInfo( ci.fields[i] );
		if ( mnode == null ){
		    resultState = ERROR; // bad news.
		} else {
		    mnode.nodeState = DependenceNode.ANALYZED;
		}
	    }
	}

	return resultState;
    }

    private MemberDependenceNode overrideAnalysis( MemberDependenceNode mn ){
	if ( mn == null ) return null; // must have been some error
	if ( (mn.flags&MemberDependenceNode.NO_OVERRIDING) != 0 )
	    return mn; // these don't override.
	MemberName nm = (MemberName)((MemberName)(mn.name())).clone(); // make a dirty copy.
	int anyOverriding = 0;
	if ( superClassEntry != null )
	    anyOverriding += superClassEntry.overrideCheckUp( mn, nm );
	Enumeration ife = interfaceSet.elements();
	while( ife.hasMoreElements() ){
	    ClassEntry iface = (ClassEntry)(ife.nextElement() );
	    anyOverriding += iface.overrideCheckUp( mn, nm );
	}
	if ( anyOverriding != 0 ){
	    this.flags |= HAS_OVERRIDING;
	}
	return mn;
    }

    private int overrideCheckUp( MemberDependenceNode mn,
	MemberName nameCopy ){

	if ( this.nodeState != ANALYZED ) return 0; // error or unanalyzed interface

	int nOverrides = 0;

	nameCopy.classEntry = this;
	MemberDependenceNode target = lookupMember( nameCopy );
	if ( target != null ){
	    // have a case of overriding.
	    // various sets may not exist yet, so be careful.
	    if ( target.memberOverriddenBy == null ){
		target.memberOverriddenBy = new util.Set();
	    }
	    target.memberOverriddenBy.addElement( mn );
	    target.flags |= MemberDependenceNode.OVERRIDDEN;