classdocimpl.java

linux下建立JAVA虚拟机的源码KAFFE

/* gnu.classpath.tools.gjdoc.ClassDocImpl
   Copyright (C) 2001 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */

package gnu.classpath.tools.gjdoc;

import com.sun.javadoc.*;
import java.util.*;
import java.io.*;
import gnu.classpath.tools.gjdoc.expr.EvaluatorEnvironment;
import gnu.classpath.tools.gjdoc.expr.CircularExpressionException;
import gnu.classpath.tools.gjdoc.expr.IllegalExpressionException;
import gnu.classpath.tools.gjdoc.expr.UnknownIdentifierException;

public class ClassDocImpl
   extends ProgramElementDocImpl 
   implements ClassDoc, WritableType, EvaluatorEnvironment {

   private ClassDoc baseClassDoc;
   private ClassDoc[] importedClasses;
   private PackageDoc[] importedPackages;
   private boolean definesSerializableFields;
   private FieldDoc[] serialPersistentField;
   private MethodDoc[] serializationMethods;
   private String dimension = "";

   public ClassDocImpl(ClassDoc containingClass,
		       PackageDoc containingPackage,
		       int accessLevel,
		       boolean isFinal,
		       boolean isStatic,
                       SourcePosition position) {
      super(containingClass, containingPackage, accessLevel, isFinal, isStatic,
            position);
      this.baseClassDoc = this;
   }

   public ClassDocImpl(ClassDoc containingClass,
		       PackageDoc containingPackage,
		       ClassDoc[] importedClasses,
		       PackageDoc[] importedPackages,
                       SourcePosition position) {
      super(containingClass, containingPackage,
            position);
      this.importedClasses=importedClasses;
      this.importedPackages=importedPackages;
      this.baseClassDoc = this;
   }   

   // Return constructors in class. 
   public ConstructorDoc[] constructors() {
      return constructors(true);
   } 

   public ConstructorDoc[] constructors(boolean filter) {
      return filter ? filteredConstructors : unfilteredConstructors;
   } 

   // Return true if Serializable fields are explicitly defined with the special class member serialPersistentFields. 
   public boolean definesSerializableFields() {
      return definesSerializableFields;
   } 

   // Return fields in class. 
   public FieldDoc[] fields() {
      return fields(true);
   } 

   public FieldDoc[] fields(boolean filter) {
      return filter ? filteredFields : unfilteredFields;
   } 

   private static Set primitiveNames;
   static {
      primitiveNames = new HashSet();
      primitiveNames.add("int");
      primitiveNames.add("long");
      primitiveNames.add("char");
      primitiveNames.add("short");
      primitiveNames.add("byte");
      primitiveNames.add("float");
      primitiveNames.add("double");
      primitiveNames.add("boolean");
   }

   private Map findClassCache = new HashMap();

   public ClassDoc findClass(String className, String dimension)
   {
      ClassDoc cached = (ClassDoc)findClassCache.get(className + dimension);
      if (null != cached) {
         return cached;
      }
      else {
         ClassDoc classDoc = findClass(className);

         if (null!=classDoc) {
            try {
               if (classDoc.dimension().equals(dimension)) {
                  return classDoc;
               }
               else {
                  ClassDoc rc = (ClassDoc) ((WritableType)classDoc).clone();
                  ((WritableType)rc).setDimension(dimension);
                  findClassCache.put(className + dimension, rc);
                  return rc;
               }
            }
            catch (CloneNotSupportedException e) {
               throw new RuntimeException(e);
            }
         }
         else {
            return null;
         }
      }
   }

   public ClassDoc findClass(String className) 
   {
      String qualifiedName = Main.getRootDoc().resolveClassName(className, this);
      ClassDoc rc=Main.getRootDoc().classNamed(qualifiedName);

      if (null == rc) { 
         for (ClassDoc cdi=this; cdi!=null; cdi=cdi.containingClass()) {
            for (ClassDoc sdi=cdi; sdi!=null; sdi=sdi.superclass()) {
               if (sdi instanceof ClassDocProxy) { 
                  ClassDoc realClass = Main.getRootDoc().classNamed(sdi.qualifiedName());
                  if (null != realClass) {
                     sdi = realClass;
                  }
               }
               rc=Main.getRootDoc().classNamed(sdi.qualifiedName()+"."+className);
               if (rc!=null) return rc;
            }
         }
      }

      return rc;
   }

   // Get the list of classes declared as imported. 
   public ClassDoc[] importedClasses() {
      return importedClasses;
   } 

   // Get the list of packages declared as imported. 
   public PackageDoc[] importedPackages() {
      return importedPackages;
   } 

   // Return inner classes within this class. 
   public ClassDoc[] innerClasses() {
      return innerClasses(true);
   } 

   public ClassDoc[] innerClasses(boolean filtered) {
      return filtered ? filteredInnerClasses : unfilteredInnerClasses;
   } 

   void setFilteredInnerClasses(ClassDoc[] filteredInnerClasses) {
      this.filteredInnerClasses=filteredInnerClasses;
   }

   void setInnerClasses(ClassDoc[] unfilteredInnerClasses) {
      this.unfilteredInnerClasses=unfilteredInnerClasses;
   }

   // Return interfaces implemented by this class or interfaces extended by this interface. 
   public ClassDoc[] interfaces() {
      return interfaces;
   } 

   public void setInterfaces(ClassDoc[] interfaces) {
      this.interfaces=interfaces;
   } 

   // Return true if this class is abstract 
   public boolean isAbstract() {
      return isAbstract || isInterface();
   } 

   public boolean isInterface() {
      return isInterface;
   }

   // Return true if this class is abstract 
   public void setIsAbstract(boolean b) {
      this.isAbstract=b;
   } 

   // Return true if this class implements java.io.Externalizable. 
   public boolean isExternalizable() {
      return implementsInterface("java.io.Externalizable");
   } 

   // Return true if this class implements java.io.Serializable. 
   public boolean isSerializable() {
      return implementsInterface("java.io.Serializable");
   } 

   public boolean implementsInterface(String name) {
      for (ClassDoc cdi=this; cdi!=null; cdi=(ClassDoc)cdi.superclass()) {
	 if (cdi instanceof ClassDocImpl) {
	    ClassDoc[] cdiInterfaces=(ClassDoc[])cdi.interfaces();
            if (null != cdiInterfaces) {
               for (int i=0; i<cdiInterfaces.length; ++i) {
                  if (cdiInterfaces[i].qualifiedName().equals(name))
                     return true;
               }
            }
	 }
	 else {
	    //throw new RuntimeException("implementsInterface(\""+name+"\") failed: Not a ClassDocImpl:"+cdi);
	 }
      }
      return false;
   }

   // Return methods in class. 
   public MethodDoc[] methods() {
      return methods(true);
   } 

   // Return methods in class. 
   public MethodDoc[] methods(boolean filter) {
      return filter ? filteredMethods : unfilteredMethods;
   } 

   // Return the Serializable fields of class. Return either a list of default fields documented by serial tag or return a single FieldDoc for serialPersistentField member. 
   public FieldDoc[] serializableFields() {
      if (serialPersistentField!=null) {
	 return serialPersistentField;
      }
      else{
	 return serializableFields;
      }
   } 

   // Return the serialization methods for this class. 
   public MethodDoc[] serializationMethods() {
      return serializationMethods;
   } 

   // Test whether this class is a subclass of the specified class. 
   public boolean subclassOf(ClassDoc cd) {
      for (ClassDocImpl cdi=(ClassDocImpl)superclass(); cdi!=null; cdi=(ClassDocImpl)cdi.superclass()) {
	 if (cdi.equals(cd))
	    return true;
      }
      return false;
   } 

   // Return the superclass of this class 
   public ClassDoc superclass() {
      return superclass;
   } 

   // Implementation of Interface Type

   public ClassDoc asClassDoc() {

      return (ClassDoc)this;
   }

   public String typeName() { return name(); }
   
   public String qualifiedTypeName() { 
      return (containingPackage()!=null && !containingPackage().equals(PackageDocImpl.DEFAULT_PACKAGE))?(containingPackage().name()+"."+name()):(name()); 
   }

   public String qualifiedName() { return qualifiedTypeName(); }

   public String dimension() { return dimension; }

   public String toString() { return "ClassDoc{"+qualifiedTypeName()+"}"; }

   public TypeVariable asTypeVariable() { return null; }

   public static ClassDocImpl createInstance(ClassDoc containingClass,
					     PackageDoc containingPackage,
					     ClassDoc[] importedClasses,
					     PackageDoc[] importedPackages,
					     char[] source, int startIndex, int endIndex,
                                             List importStatementList) throws ParseException, IOException {

      String superclassName = "java.lang.Object";

      ClassDocImpl rc=new ClassDocImpl(containingClass,
				       containingPackage,
				       importedClasses,
				       importedPackages,
                                       null);
      rc.setImportStatementList(importStatementList);
      List implementedInterfaces = new ArrayList();
      
      String word="";
      int item=0;
      
      final int STATE_NORMAL = 1;
      final int STATE_SLASHC = 2;
      final int STATE_STARC  = 3;

      int state=STATE_NORMAL;
      int varLevel=0;
      char prev=0;
      for (int ndx=startIndex; ndx<=endIndex; ++ndx) {
	 char c=(ndx==endIndex)?10:source[ndx];
	 boolean processWord=false;
	 if (state==STATE_SLASHC) {
	    if (c=='\n') {
	       state=STATE_NORMAL;
	       c=0;
	    }
	 }
	 else if (state==STATE_STARC) {
	    if (c=='/' && prev=='*') {
	       state=STATE_NORMAL;
	       c=0;
	    }
	 }
	 else {
	    if (c=='/' && prev=='/') {
	       state=STATE_SLASHC;
	       c=0;
	       word=word.substring(0,word.length()-1);
	       processWord=true;
	    }
	    else if (c=='*' && prev=='/') {
	       state=STATE_STARC;
	       c=0;
	       word=word.substring(0,word.length()-1);
	       processWord=true;
	    }
	    else if (c=='<')
	      {
		++varLevel;
		word += c;
	      }
	    else if (c=='>')
	      {
		--varLevel;
		word += c;
	      }
	    else if (c=='{' || c==',' && varLevel == 0 || 
		     Parser.WHITESPACE.indexOf(c)>=0) {
	       processWord=true;
	    }
	    else {
	       word+=c;
	    }

	    if (processWord && word.length()>0) {
	       if (item==0) {
		  if (rc.processModifier(word)) {
		  }
		  else if (word.equals("abstract")) {
		     rc.setIsAbstract(true);
		  }
		  else if (word.equals("class")) {
		     rc.setIsInterface(false);
		     item=1;
		  }
		  else if (word.equals("interface")) {
		     rc.setIsInterface(true);
		     item=1;
		  }
		  else if (word.equals("strictfp")) {
		  }
		  else {
		     Main.getRootDoc().printWarning("unknown modifier '"+word+"'");
		  }
	       }
	       else if (word.equals("extends")) {
                  if (rc.isInterface()) {
                     item=3;
                  }
                  else {
                     item=2;
                  }
	       }
	       else if (word.equals("implements")) {
		  item=3;