classdocimpl.java

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

      return rc;
   }

   public boolean isException() {
      for (ClassDoc cdi=this; 
	   cdi!=null; 
	   cdi=cdi.superclass()) {

	 if ("java.lang.Exception".equals(cdi.qualifiedName()))
	    return true;
      }
      return false;
   }

   public boolean isError() {
      for (ClassDoc cdi=this; cdi!=null; cdi=cdi.superclass()) {
	 if ("java.lang.Error".equals(cdi.qualifiedName()))
	    return true;
      }
      return false;
   }

   public boolean isOrdinaryClass() {
      return !isException() && !isError() && !isInterface();
   }

   public void setIsInterface(boolean b) {
      this.isInterface=b;
   }

   public ExecutableMemberDoc findExecutableRec(String nameAndSignature) {

      ExecutableMemberDoc rc;
      for (ClassDoc cdi=this; cdi!=null; ) {
	 rc=findMethod(cdi, nameAndSignature);
	 if (rc!=null) return rc;
	 rc=findConstructor(cdi, nameAndSignature);
	 if (rc!=null) return rc;

	 ClassDoc _superclass = cdi.superclass();
	 if (null == _superclass) {
	    break;
	 }
	 else {
	    cdi = _superclass;
	 }
      }
      return null; 
  } 

   public static ConstructorDoc findConstructor(ClassDoc classDoc, String nameAndSignature) {
      int ndx=nameAndSignature.indexOf('(');
      if (ndx<=0)
	 return null;
      else {
         String fullSignature = resolveSignature(classDoc, nameAndSignature.substring(ndx));
	 return findConstructor(classDoc,
                                nameAndSignature.substring(0,ndx),
                                fullSignature);
      }
   }

   public static ConstructorDoc findConstructor(ClassDoc classDoc, String name, String signature) {
      ConstructorDoc[] filteredConstructors = classDoc.constructors(true);
      if (null != filteredConstructors) {
         for (int i=0; i<filteredConstructors.length; ++i) {
            ConstructorDoc constructor = filteredConstructors[i];
            if (constructor.name().equals(name) && constructor.signature().equals(signature))
               return constructor;
         }
      }
      return null;
   }

   public static MethodDoc findMethod(ClassDoc classDoc, String nameAndSignature) {
      int ndx=nameAndSignature.indexOf('(');
      if (ndx<=0) {
	 return null;
      }
      else {
         String name = nameAndSignature.substring(0,ndx);
         String fullSignature = resolveSignature(classDoc, nameAndSignature.substring(ndx));
	 return findMethod(classDoc, name, fullSignature);
      }
   }

   private static String resolveSignature(ClassDoc classDoc, String signature) 
   {
      signature = signature.substring(1, signature.length() - 1).trim();
      if (0 == signature.length()) {
         return "()";
      }
      StringTokenizer st = new StringTokenizer(signature, ",");
      StringBuffer fullSignature = new StringBuffer("(");
      while (st.hasMoreTokens()) {
         String type = st.nextToken().trim();
         int ndx = type.length();
         while (ndx > 0 && type.charAt(ndx - 1) == '[' || type.charAt(ndx - 1) == ']') {
            -- ndx;
         }
         String dim = type.substring(ndx);
         type = type.substring(0, ndx);
         ClassDoc typeClass = classDoc.findClass(type);
         if (fullSignature.length() > 1) {
            fullSignature.append(",");
         }
         if (null != typeClass) {
            fullSignature.append(typeClass.qualifiedName());
         }
         else {
            fullSignature.append(type);
         }
         fullSignature.append(dim);
      }
      fullSignature.append(')');
      return fullSignature.toString();
   }

   public static MethodDoc findMethod(ClassDoc classDoc, String name, String signature) {
      MethodDoc[] filteredMethods = classDoc.methods(true);
      if (null != filteredMethods) {
         for (int i=0; i<filteredMethods.length; ++i) {
            MethodDoc method = filteredMethods[i];
            if (method.name().equals(name) && method.signature().equals(signature))
               return method;
         }
      }
      return null;
   }

   public boolean equals(Object o) {
      return (o!=null) && (o instanceof ClassDoc) && ((ClassDoc)o).qualifiedName().equals(qualifiedName());
   }

   private List maybeSerMethodList;
   
   void setMaybeSerMethodList(List maybeSerMethodList) {
      this.maybeSerMethodList=maybeSerMethodList;
   }

   public void setDimension(String dimension) {
      this.dimension = dimension;
   }

   public Object clone() throws CloneNotSupportedException {
      ClassDocImpl result = (ClassDocImpl)super.clone();
      result.baseClassDoc = baseClassDoc;
      return result;
   }

   public int superHashCode()
   {
      return super.hashCode();
   }

   public int hashCode()
   {
      return qualifiedTypeName().hashCode();
   }

   public ClassDoc getBaseClassDoc()
   {
      return baseClassDoc;
   }
   
   public FieldDoc getFieldDoc(String name)
   {
      for (int i=0; i<unfilteredFields.length; ++i) {
         if (name.equals(unfilteredFields[i].name())) {
            return unfilteredFields[i];
         }
      }
      return null;
   }

   public MethodDoc getMethodDoc(String name, String signature)
   {
      for (int i=0; i<unfilteredMethods.length; ++i) {
         if (name.equals(unfilteredMethods[i].name())
             && signature.equals(unfilteredMethods[i].signature())) {
            return unfilteredMethods[i];
         }
      }
      return null;
   }


   public ConstructorDoc getConstructorDoc(String signature)
   {
      for (int i=0; i<unfilteredConstructors.length; ++i) {
         if (signature.equals(unfilteredConstructors[i].signature())) {
            return unfilteredConstructors[i];
         }
      }
      return null;
   }

   private Object findFieldValue(String identifier,
                                 ClassDoc classDoc, 
                                 String fieldName,
                                 Set visitedFields)
      throws UnknownIdentifierException, IllegalExpressionException
   {
      while (classDoc != null) {
         if (classDoc instanceof ClassDocImpl) {
            FieldDocImpl fieldDoc 
               = (FieldDocImpl)((ClassDocImpl)classDoc).getFieldDoc(fieldName);
            if (visitedFields.contains(fieldDoc)) {
               throw new CircularExpressionException("Circular reference detected");
            }
            else if (null != fieldDoc) {
               return fieldDoc.constantValue(visitedFields);
            }
         }
         else {
            ClassDoc[] _interfaces = classDoc.interfaces();
            if (null != _interfaces) {
               for (int i=0; i<_interfaces.length; ++i) {
                  if (_interfaces[i] instanceof ClassDocImpl) { 
                     FieldDocImpl fieldDoc 
                        = (FieldDocImpl)((ClassDocImpl)_interfaces[i]).getFieldDoc(fieldName);
                     if (visitedFields.contains(fieldDoc)) {
                        throw new CircularExpressionException("Circular reference detected");
                     }
                     else if (null != fieldDoc) {
                        return fieldDoc.constantValue(visitedFields);
                     }
                  }
               }
            }
         }
         classDoc = classDoc.superclass();
      }
      throw new UnknownIdentifierException(identifier);
   }
   
   public Object getValue(String identifier, Set visitedFields)
      throws UnknownIdentifierException, IllegalExpressionException
   {
      int ndx = identifier.lastIndexOf('.');
      if (ndx >= 0) {
         String _className = identifier.substring(0, ndx);
         String _fieldName = identifier.substring(ndx + 1);

         ClassDoc _classDoc = findClass(_className);
         if (null != _classDoc) {
            return findFieldValue(identifier, _classDoc, _fieldName, visitedFields);
         }
         else {
            throw new UnknownIdentifierException(identifier);
         }
      }
      else {
         return findFieldValue(identifier, this, identifier, visitedFields);
      }
   }

   public boolean isPrimitive()
   {
      return false;
   }

   // Compares this Object with the specified Object for order. 
   public int compareTo(java.lang.Object o) {
      int rc;

      if (o instanceof ClassDocImpl) {
      
         ClassDocImpl c1 = this;
         ClassDocImpl c2 = (ClassDocImpl)o;

         if (null != c1.containingClass() && null == c2.containingClass()) {
            rc = c1.containingClass().compareTo(c2);
            if (0 == rc) {
               rc = 1;
            }
            return rc;
         }
         else if (null == c1.containingClass() && null != c2.containingClass()) {
            rc = c1.compareTo(c2.containingClass());
            if (0 == rc) {
               rc = -1;
            }
            return rc;
         }
         else if (null != c1.containingClass() && null != c2.containingClass()) {
            rc = c1.containingClass().compareTo(c2.containingClass());
            if (0 != rc) {
               return rc;
            }
         }

         rc = super.compareTo(o);
         if (0 == rc) {
            return Main.getInstance().getCollator().compare(containingPackage().name(), 
                                                            ((ClassDocImpl)o).containingPackage().name());
         }
         else {
            return rc;
         }
      }
      else {
         return 1;
      }
   } 

   private List importStatementList;

   public void setImportStatementList(List importStatementList)
   {
      this.importStatementList = new LinkedList();
      this.importStatementList.addAll(importStatementList);
   }
   
   public List getImportSpecifierList()
   {
      return importStatementList;
   }

  public TypeVariable[] typeParameters()
  {
    return typeParameters;
  }

  /**
   * <p>
   * Parses the type variables declared in the class definition.
   * The syntax is:
   * </p>
   * <p>
   * <dl>
   * <dt>TypeParameters:</dt>
   * <dd><code>&lt; <em>TypeParameter</em> { <em>, TypeParameter }</code></dd>
   * <dt>TypeParameter:</dt>
   * <dd><code><em>Identifier</em> { <strong>extends</strong> <em>Bound</em>
   *     }</dd>
   * <dt>Bound:</dt>
   * <dd><code><em>Type</em>{<strong>&</strong> <em>Type</em> } </dd>
   * </dl>
   *
   * @param rc the owning class.
   * @param typeVariables the string to be parsed.
   * @throws ParseException if parsing fails.
   */
  public static void parseTypeVariables(ClassDocImpl rc,
					String typeVariables)
    throws ParseException
  {
    List parsedBounds = null;
    StringTokenizer parameters = new StringTokenizer(typeVariables,
						     Parser.WHITESPACE +
						     "<>,");
    List variables = new ArrayList();
    while (parameters.hasMoreTokens())
      {
	String parameter = parameters.nextToken();
	StringTokenizer parts = new StringTokenizer(parameter,
						    Parser.WHITESPACE);
	TypeVariableImpl variable = new TypeVariableImpl(rc.qualifiedName(),
							 parts.nextToken(),"",
							 rc);
	if (parts.hasMoreTokens())
	  {
	    if (!parts.nextToken().equals("extends"))
	      throw new ParseException("Invalid type parameter: " + parameter);
	    StringTokenizer bounds = new StringTokenizer(parts.nextToken(),
							 Parser.WHITESPACE
							 + "&");
	    parsedBounds = new ArrayList();
	    while (bounds.hasMoreTokens())
	      {
		String bound = bounds.nextToken();
		int nameSep = bound.lastIndexOf(".");
		String packageName = bound.substring(0, nameSep);
		String boundName = bound.substring(nameSep, bound.length());
		parsedBounds.add(new TypeImpl(packageName,boundName,""));
	      }
	  }
	if (parsedBounds != null)
	  variable.setBounds(parsedBounds);
	variables.add(variable);
      }
    rc.setTypeParameters(variables);
  }

  /**
   * Set the type parameters to the contents of the supplied list.
   *
   * @param variables a list of type parameters.
   */
  void setTypeParameters(List variables)
  {
    typeParameters = 
      (TypeVariable[]) variables.toArray(new TypeVariable[variables.size()]);
  }

}