classdocimpl.java

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

	       }
	       else if (item==1) {
		 int parameterIndex = word.indexOf("<");
		 if (parameterIndex == -1)
		   rc.setClass(word);
		 else
		   {
		     rc.setClass(word.substring(0, parameterIndex));
		     parseTypeVariables(rc,word.substring(parameterIndex,
							  word.length()));
		   }
	       }
	       else if (item==2) {
		  //Debug.log(9,"setting baseclass of "+rc+" to "+word);
		 int parameterIndex = word.indexOf("<");
		 if (parameterIndex == -1)
		   superclassName=word;
		 else
		   {
		     /* FIXME: Parse type parameters */
		     superclassName=word.substring(0,parameterIndex);
		   }
	       }
	       else if (item==3) {
		 int parameterIndex = word.indexOf("<");
		 if (parameterIndex == -1)
		   implementedInterfaces.add(word);
		 else
		   {
		     /* FIXME: Parse type parameters */
		     implementedInterfaces.add(word.substring(0,parameterIndex));
		   }
	       }      
	       word="";
	    }

	    if (c=='{') break;
	 }
	 prev=c;
      }

      if (null != containingClass
          && containingClass.isInterface()) {
         rc.accessLevel = ACCESS_PUBLIC;
      }

      if (rc.name()==null) {
	 throw new ParseException("No classdef found in expression \""+new String(source,startIndex,endIndex-startIndex)+"\"");
      }

      rc.setPosition(ClassDocImpl.getPosition(rc, source, startIndex));

      ClassDoc superclassProxy=new ClassDocProxy(superclassName, rc);

      if (!rc.qualifiedName().equals("java.lang.Object")) {
	 rc.setSuperclass(superclassProxy);
      }

      ClassDoc[] interfaces=new ClassDoc[implementedInterfaces.size()];
      for (int i=0; i<interfaces.length; ++i) {
         interfaces[i]=new ClassDocProxy((String)implementedInterfaces.get(i), rc);
      }
      rc.setInterfaces(interfaces);

      if (rc.isInterface() && rc.containingClass()!=null) {
	 rc.setIsStatic(true);
      }
      return rc;
   }

   public void setFields(FieldDoc[] fields) {
      this.unfilteredFields=fields;
   }

   public void setFilteredFields(FieldDoc[] fields) {
      this.filteredFields=fields;
   }

   public void setSerializableFields(FieldDoc[] sfields) {
      this.serializableFields=sfields;
   }

   public void setMethods(MethodDoc[] methods) {
      this.unfilteredMethods=methods;
   }

   public void setFilteredMethods(MethodDoc[] methods) {
      this.filteredMethods=methods;
   }

   public void setConstructors(ConstructorDoc[] constructors) {
      this.unfilteredConstructors=constructors;
   }

   public void setFilteredConstructors(ConstructorDoc[] constructors) {
      this.filteredConstructors=constructors;
   }

   // Returns the name of this Doc item. 
   public String name() {
      if (containingClass==null) {
	 return className;
      }
      else {
	 return containingClass.name()+"."+className;
      }
   } 

   public String getClassName() {
      return className;
   }

   public void setClass(String className) {
      this.className=className;
   }

   void setSuperclass(ClassDoc superclass) {
      this.superclass=superclass;
   }

   public void resolve() throws ParseException {
      if (!resolved) {
	 resolved=true;

	 if (containingClass!=null)
	    ((ClassDocImpl)containingClass).resolve();

	 //Debug.log(9,"resolving class '"+qualifiedName()+"'");
	 /*
	 for (int i=0; i<importedPackages.length; ++i) {
	       Debug.log(9,"class "+qualifiedName()+" imports "+importedPackages[i].name());
	 }
	 */

	 if (superclass instanceof ClassDocProxy) {

	    ClassDoc realClassDoc=findClass(superclass.qualifiedName());

	    if (realClassDoc==null) {
	       /*
	       if (true) { // Main.recursiveClasses) {
		  throw new ParseException("In class '"+qualifiedName()+"': class '"+className+"' not found.");
	       }
	       */
	    }
	    else {
	       superclass=realClassDoc;
	    }
	 }

         if (null != interfaces) {
            for (int i=0; i<interfaces.length; ++i) {
               if (interfaces[i] instanceof ClassDocProxy) {
                  //Debug.log(9,"class "+qualifiedName()+" implements "+interfaces[i].qualifiedName());
                  ClassDoc realClassDoc=findClass(interfaces[i].qualifiedName());
                  if (realClassDoc==null) {
                     /*
                       if (Main.recursiveClasses) {
                       throw new ParseException("In class '"+qualifiedName()+"': class '"+className+"' not found.");
                       }
                     */
                  }
                  else {
                     //Debug.log(9,"found class '"+className+"': "+interfaces[i]);
                     interfaces[i]=realClassDoc;
                  }
               }
            }
         }

	 if (unfilteredFields!=null) {
            for (int i=0; i<unfilteredFields.length; ++i) {
               ((FieldDocImpl)unfilteredFields[i]).resolve();
               if (unfilteredFields[i].name().equals("serialPersistentField")) {
                  serialPersistentField=new FieldDoc[]{unfilteredFields[i]};
                  definesSerializableFields=true;
               }
            }
         }

         if (unfilteredMethods!=null) {
            for (int i=0; i<unfilteredMethods.length; ++i) {
               ((MethodDocImpl)unfilteredMethods[i]).resolve();
            }
         }

         if (unfilteredConstructors!=null) {
            for (int i=0; i<unfilteredConstructors.length; ++i) {
               ((ConstructorDocImpl)unfilteredConstructors[i]).resolve();
            }
         }

	 List isSerMethodList=new ArrayList();

         if (null != maybeSerMethodList) {
            for (Iterator it=maybeSerMethodList.iterator(); it.hasNext(); ) {
               MethodDocImpl method=(MethodDocImpl)it.next();
               method.resolve();

               if (((method.name().equals("readObject")
                     && method.signature().equals("(java.io.ObjectInputStream)"))
                    || (method.name().equals("writeObject")
                        && method.signature().equals("(java.io.ObjectOutputStream)"))
                    || (method.name().equals("readExternal")
                        && method.signature().equals("(java.io.ObjectInput)"))
                    || (method.name().equals("writeExternal")
                        && method.signature().equals("(java.io.ObjectOutput)"))
                    || (method.name().equals("readResolve")
                        && method.signature().equals("()")))) {

                  isSerMethodList.add(method);
               }
            }
            this.serializationMethods=(MethodDoc[])isSerMethodList.toArray(new MethodDoc[0]);
            maybeSerMethodList=null;
         }
      }
   }

   public FieldDoc findFieldRec(String name) {
      return findFieldRec(this, name);
   }

   private static FieldDoc findFieldRec(ClassDoc classDoc, String name)
   {
      FieldDoc field = findField(classDoc, name);
      if (null!=field) {
         return field;
      }
      else {
         ClassDoc[] interfaces = classDoc.interfaces();
         for (int i=0; i<interfaces.length; ++i) {
            field = findFieldRec(interfaces[i], name);
            if (null != field) {
               return field;
            }
         }
         if (null != classDoc.superclass()) {
            return findFieldRec(classDoc.superclass(), name);
         }
         else {
            return null;
         }
      }
   }

   private static FieldDoc findField(ClassDoc classDoc, String name)
   {
      FieldDoc[] fields = classDoc.fields(false);
      for (int i=0; i<fields.length; ++i) {
         if (fields[i].name().equals(name)) {
            return fields[i];
         }
      }
      return null;
   }

   public FieldDoc findField(String fieldName) {
      for (int i=0; i<filteredFields.length; ++i) {
	 if (filteredFields[i].name().equals(fieldName)) {
	    return filteredFields[i];
	 }
      }
      return null;
   }

   public void resolveComments() {

      super.resolveComments();

      if (null != unfilteredFields) {
         for (int i=0; i<unfilteredFields.length; ++i) {
            ((FieldDocImpl)unfilteredFields[i]).resolveComments();
         }
      }

      if (null != serializableFields) {
         for (int i=0; i<serializableFields.length; ++i) {
            ((FieldDocImpl)serializableFields[i]).resolveComments();
         }
      }
      if (null != unfilteredMethods) {
         for (int i=0; i<unfilteredMethods.length; ++i) {
            ((MethodDocImpl)unfilteredMethods[i]).resolveComments();
         }
      }
      if (null != unfilteredConstructors) {
         for (int i=0; i<unfilteredConstructors.length; ++i) {
            ((ConstructorDocImpl)unfilteredConstructors[i]).resolveComments();
         }
      }

      resolveTags();
   }


   private String className=null;

   private boolean isAbstract;
   private boolean isInterface;
   private ClassDoc[] interfaces;
   private ClassDoc[] filteredInnerClasses;
   private ClassDoc[] unfilteredInnerClasses;
   private FieldDoc[] filteredFields;
   private FieldDoc[] unfilteredFields;
   private FieldDoc[] serializableFields;
   private MethodDoc[] filteredMethods;
   private MethodDoc[] unfilteredMethods;
   private ConstructorDoc[] filteredConstructors;
   private ConstructorDoc[] unfilteredConstructors;
   private TypeVariable[] typeParameters;

   private boolean resolved=false;

   private ClassDoc superclass;

   // Is this Doc item a class. 
   public boolean isClass() {
      return !isInterface;
   } 

   // return true if this Doc is include in the active set. 
   public boolean isIncluded() {
      if (this == baseClassDoc) {
         return isIncluded
            || (null != containingClass && Main.getInstance().includeAccessLevel(accessLevel));
      }
      else {
         return baseClassDoc.isIncluded();
      }
   } 

   void setIsIncluded(boolean b) {
      this.isIncluded=b;
   }

   private boolean isIncluded=false;

   void setImportedClasses(ClassDoc[] importedClasses) {
      this.importedClasses=importedClasses;
   }

   private static Map typeMap = new HashMap();

   Type typeForString(String typeName) throws ParseException {
      String orgTypename=typeName;
      int ndx=typeName.indexOf('[');
      String dim="";
      if (ndx>=0) {
	 for (int i=ndx; i<typeName.length(); ++i) {
	    if ("[]".indexOf(typeName.charAt(i))>=0) {
	       dim+=typeName.charAt(i);
	    }
	 }
	 typeName=typeName.substring(0,ndx).trim();
      }

      ClassDoc classDoc = findClass(typeName, dim);
      if (null != classDoc) {
         return classDoc;
      }

      Type type = (Type)typeMap.get(typeName+dim);
      if (null!=type) {
	 try {
            if (type.dimension().equals(dim)) {
               return type;
            }
            else {
               Type rc = (Type) ((WritableType)type).clone();
               ((WritableType)rc).setDimension(dim);
               return rc;
            }
	 }
	 catch (CloneNotSupportedException e) {
	    throw new ParseException(e.toString());
	 }
      }
      
      if ("boolean".equals(typeName)
	  || "char".equals(typeName)
	  || "byte".equals(typeName)
	  || "short".equals(typeName)
	  || "int".equals(typeName)
	  || "long".equals(typeName)
	  || "void".equals(typeName)
	  || "float".equals(typeName)
	  || "double".equals(typeName)) {
	 Type rc=new TypeImpl(null, typeName, dim);
	 typeMap.put(typeName+dim, rc);
	 return rc;
      }

      if (Main.getInstance().isDocletRunning()) {
	 //System.err.println(findClass("java.lang.String"));
	 //throw new ParseException("Doclet running, class not found: "+typeName+" ("+orgTypename+")");
      }
      Type rc=new ClassDocProxy(typeName, this);
      ((WritableType)rc).setDimension(dim);