methoddecl.java

来自「JDK1.4编译器前端」· Java 代码 · 共 1,272 行 · 第 1/4 页

 @SuppressWarnings({"unchecked", "cast"})     public boolean contains(Object o) {
        Object _parameters = o;
if(contains_Object_visited == null) contains_Object_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(contains_Object_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: contains in class: ");
        contains_Object_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean contains_Object_value = contains_compute(o);
        contains_Object_visited.remove(_parameters);
        return contains_Object_value;
    }

    private boolean contains_compute(Object o) {  return this == o;  }

    protected int lineNumber_visited = -1;
    // Declared in ErrorCheck.jrag at line 31
 @SuppressWarnings({"unchecked", "cast"})     public int lineNumber() {
        if(lineNumber_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: lineNumber in class: ");
        lineNumber_visited = boundariesCrossed;
        int lineNumber_value = lineNumber_compute();
        lineNumber_visited = -1;
        return lineNumber_value;
    }

    private int lineNumber_compute() {  return getLine(IDstart);  }

    protected java.util.Map throwsException_TypeDecl_visited;
    protected java.util.Map throwsException_TypeDecl_values;
    // Declared in ExceptionHandling.jrag at line 123
 @SuppressWarnings({"unchecked", "cast"})     public boolean throwsException(TypeDecl exceptionType) {
        Object _parameters = exceptionType;
if(throwsException_TypeDecl_visited == null) throwsException_TypeDecl_visited = new java.util.HashMap(4);
if(throwsException_TypeDecl_values == null) throwsException_TypeDecl_values = new java.util.HashMap(4);
        if(throwsException_TypeDecl_values.containsKey(_parameters))
            return ((Boolean)throwsException_TypeDecl_values.get(_parameters)).booleanValue();
        if(new Integer(boundariesCrossed).equals(throwsException_TypeDecl_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: throwsException in class: ");
        throwsException_TypeDecl_visited.put(_parameters, new Integer(boundariesCrossed));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        boolean throwsException_TypeDecl_value = throwsException_compute(exceptionType);
        if(isFinal && num == boundariesCrossed)
            throwsException_TypeDecl_values.put(_parameters, Boolean.valueOf(throwsException_TypeDecl_value));
        throwsException_TypeDecl_visited.remove(_parameters);
        return throwsException_TypeDecl_value;
    }

    private boolean throwsException_compute(TypeDecl exceptionType) {
    for(int i = 0; i < getNumException(); i++)
      if(exceptionType.instanceOf(getException(i).type()))
        return true;
    return false;
  }

    protected int name_visited = -1;
    // Declared in LookupMethod.jrag at line 125
 @SuppressWarnings({"unchecked", "cast"})     public String name() {
        if(name_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: name in class: ");
        name_visited = boundariesCrossed;
        String name_value = name_compute();
        name_visited = -1;
        return name_value;
    }

    private String name_compute() {  return getID();  }

    protected int signature_visited = -1;
    protected boolean signature_computed = false;
    protected String signature_value;
    // Declared in LookupMethod.jrag at line 128
 @SuppressWarnings({"unchecked", "cast"})     public String signature() {
        if(signature_computed)
            return signature_value;
        if(signature_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: signature in class: ");
        signature_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        signature_value = signature_compute();
        if(isFinal && num == boundariesCrossed)
            signature_computed = true;
        signature_visited = -1;
        return signature_value;
    }

    private String signature_compute() {
    StringBuffer s = new StringBuffer();
    s.append(name() + "(");
    for(int i = 0; i < getNumParameter(); i++) {
      if(i != 0) s.append(", ");
      s.append(getParameter(i).type().typeName());
    }
    s.append(")");
    return s.toString();
  }

    protected java.util.Map sameSignature_MethodDecl_visited;
    // Declared in LookupMethod.jrag at line 140
 @SuppressWarnings({"unchecked", "cast"})     public boolean sameSignature(MethodDecl m) {
        Object _parameters = m;
if(sameSignature_MethodDecl_visited == null) sameSignature_MethodDecl_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(sameSignature_MethodDecl_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: sameSignature in class: ");
        sameSignature_MethodDecl_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean sameSignature_MethodDecl_value = sameSignature_compute(m);
        sameSignature_MethodDecl_visited.remove(_parameters);
        return sameSignature_MethodDecl_value;
    }

    private boolean sameSignature_compute(MethodDecl m) {  return signature().equals(m.signature());  }

    protected java.util.Map moreSpecificThan_MethodDecl_visited;
    protected java.util.Map moreSpecificThan_MethodDecl_values;
    // Declared in LookupMethod.jrag at line 142
 @SuppressWarnings({"unchecked", "cast"})     public boolean moreSpecificThan(MethodDecl m) {
        Object _parameters = m;
if(moreSpecificThan_MethodDecl_visited == null) moreSpecificThan_MethodDecl_visited = new java.util.HashMap(4);
if(moreSpecificThan_MethodDecl_values == null) moreSpecificThan_MethodDecl_values = new java.util.HashMap(4);
        if(moreSpecificThan_MethodDecl_values.containsKey(_parameters))
            return ((Boolean)moreSpecificThan_MethodDecl_values.get(_parameters)).booleanValue();
        if(new Integer(boundariesCrossed).equals(moreSpecificThan_MethodDecl_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: moreSpecificThan in class: ");
        moreSpecificThan_MethodDecl_visited.put(_parameters, new Integer(boundariesCrossed));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        boolean moreSpecificThan_MethodDecl_value = moreSpecificThan_compute(m);
        if(isFinal && num == boundariesCrossed)
            moreSpecificThan_MethodDecl_values.put(_parameters, Boolean.valueOf(moreSpecificThan_MethodDecl_value));
        moreSpecificThan_MethodDecl_visited.remove(_parameters);
        return moreSpecificThan_MethodDecl_value;
    }

    private boolean moreSpecificThan_compute(MethodDecl m) {
    if(getNumParameter() == 0)
      return false;
    for(int i = 0; i < getNumParameter(); i++) {
      if(!getParameter(i).type().instanceOf(m.getParameter(i).type()))
        return false;
    }
    return true;
  }

    protected java.util.Map overrides_MethodDecl_visited;
    protected java.util.Map overrides_MethodDecl_values;
    // Declared in LookupMethod.jrag at line 183
 @SuppressWarnings({"unchecked", "cast"})     public boolean overrides(MethodDecl m) {
        Object _parameters = m;
if(overrides_MethodDecl_visited == null) overrides_MethodDecl_visited = new java.util.HashMap(4);
if(overrides_MethodDecl_values == null) overrides_MethodDecl_values = new java.util.HashMap(4);
        if(overrides_MethodDecl_values.containsKey(_parameters))
            return ((Boolean)overrides_MethodDecl_values.get(_parameters)).booleanValue();
        if(new Integer(boundariesCrossed).equals(overrides_MethodDecl_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: overrides in class: ");
        overrides_MethodDecl_visited.put(_parameters, new Integer(boundariesCrossed));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        boolean overrides_MethodDecl_value = overrides_compute(m);
        if(isFinal && num == boundariesCrossed)
            overrides_MethodDecl_values.put(_parameters, Boolean.valueOf(overrides_MethodDecl_value));
        overrides_MethodDecl_visited.remove(_parameters);
        return overrides_MethodDecl_value;
    }

    private boolean overrides_compute(MethodDecl m) {  return !isStatic() && !m.isPrivate() && m.accessibleFrom(hostType()) && 
     hostType().instanceOf(m.hostType()) && m.signature().equals(signature());  }

    protected java.util.Map hides_MethodDecl_visited;
    protected java.util.Map hides_MethodDecl_values;
    // Declared in LookupMethod.jrag at line 187
 @SuppressWarnings({"unchecked", "cast"})     public boolean hides(MethodDecl m) {
        Object _parameters = m;
if(hides_MethodDecl_visited == null) hides_MethodDecl_visited = new java.util.HashMap(4);
if(hides_MethodDecl_values == null) hides_MethodDecl_values = new java.util.HashMap(4);
        if(hides_MethodDecl_values.containsKey(_parameters))
            return ((Boolean)hides_MethodDecl_values.get(_parameters)).booleanValue();
        if(new Integer(boundariesCrossed).equals(hides_MethodDecl_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: hides in class: ");
        hides_MethodDecl_visited.put(_parameters, new Integer(boundariesCrossed));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        boolean hides_MethodDecl_value = hides_compute(m);
        if(isFinal && num == boundariesCrossed)
            hides_MethodDecl_values.put(_parameters, Boolean.valueOf(hides_MethodDecl_value));
        hides_MethodDecl_visited.remove(_parameters);
        return hides_MethodDecl_value;
    }

    private boolean hides_compute(MethodDecl m) {  return isStatic() && !m.isPrivate() && m.accessibleFrom(hostType()) && 
     hostType().instanceOf(m.hostType()) && m.signature().equals(signature());  }

    protected java.util.Map parameterDeclaration_String_visited;
    protected java.util.Map parameterDeclaration_String_values;
    // Declared in LookupVariable.jrag at line 99
 @SuppressWarnings({"unchecked", "cast"})     public SimpleSet parameterDeclaration(String name) {
        Object _parameters = name;
if(parameterDeclaration_String_visited == null) parameterDeclaration_String_visited = new java.util.HashMap(4);
if(parameterDeclaration_String_values == null) parameterDeclaration_String_values = new java.util.HashMap(4);
        if(parameterDeclaration_String_values.containsKey(_parameters))
            return (SimpleSet)parameterDeclaration_String_values.get(_parameters);
        if(new Integer(boundariesCrossed).equals(parameterDeclaration_String_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: parameterDeclaration in class: ");
        parameterDeclaration_String_visited.put(_parameters, new Integer(boundariesCrossed));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        SimpleSet parameterDeclaration_String_value = parameterDeclaration_compute(name);
        if(isFinal && num == boundariesCrossed)
            parameterDeclaration_String_values.put(_parameters, parameterDeclaration_String_value);
        parameterDeclaration_String_visited.remove(_parameters);
        return parameterDeclaration_String_value;
    }

    private SimpleSet parameterDeclaration_compute(String name) {
    for(int i = 0; i < getNumParameter(); i++)
      if(getParameter(i).name().equals(name))
        return (ParameterDeclaration)getParameter(i);
    return SimpleSet.emptySet;
  }

    protected int isSynthetic_visited = -1;
    // Declared in Modifiers.jrag at line 213
 @SuppressWarnings({"unchecked", "cast"})     public boolean isSynthetic() {
        if(isSynthetic_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isSynthetic in class: ");
        isSynthetic_visited = boundariesCrossed;
        boolean isSynthetic_value = isSynthetic_compute();
        isSynthetic_visited = -1;
        return isSynthetic_value;
    }

    private boolean isSynthetic_compute() {  return getModifiers().isSynthetic();  }

    protected int isPublic_visited = -1;
    // Declared in Modifiers.jrag at line 222
 @SuppressWarnings({"unchecked", "cast"})     public boolean isPublic() {
        if(isPublic_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isPublic in class: ");
        isPublic_visited = boundariesCrossed;
        boolean isPublic_value = isPublic_compute();
        isPublic_visited = -1;
        return isPublic_value;
    }

    private boolean isPublic_compute() {  return getModifiers().isPublic() || hostType().isInterfaceDecl();  }

    protected int isPrivate_visited = -1;
    // Declared in Modifiers.jrag at line 223
 @SuppressWarnings({"unchecked", "cast"})     public boolean isPrivate() {
        if(isPrivate_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isPrivate in class: ");
        isPrivate_visited = boundariesCrossed;
        boolean isPrivate_value = isPrivate_compute();
        isPrivate_visited = -1;
        return isPrivate_value;
    }

    private boolean isPrivate_compute() {  return getModifiers().isPrivate();  }

    protected int isProtected_visited = -1;
    // Declared in Modifiers.jrag at line 224
 @SuppressWarnings({"unchecked", "cast"})     public boolean isProtected() {
        if(isProtected_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isProtected in class: ");
        isProtected_visited = boundariesCrossed;
        boolean isProtected_value = isProtected_compute();
        isProtected_visited = -1;
        return isProtected_value;
    }

    private boolean isProtected_compute() {  return getModifiers().isProtected();  }

    protected int isAbstract_visited = -1;
    // Declared in Modifiers.jrag at line 225
 @SuppressWarnings({"unchecked", "cast"})     public boolean isAbstract() {
        if(isAbstract_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isAbstract in class: ");
        isAbstract_visited = boundariesCrossed;
        boolean isAbstract_value = isAbstract_compute();
        isAbstract_visited = -1;
        return isAbstract_value;
    }

    private boolean isAbstract_compute() {  return getModifiers().isAbstract() || hostType().isInterfaceDecl();  }

    protected int isStatic_visited = -1;
    // Declared in Modifiers.jrag at line 226
 @SuppressWarnings({"unchecked", "cast"})     public boolean isStatic() {
        if(isStatic_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isStatic in class: ");
        isStatic_visited = boundariesCrossed;
        boolean isStatic_value = isStatic_compute();
        isStatic_visited = -1;
        return isStatic_value;
    }

    private boolean isStatic_compute() {  return getModifiers().isStatic();  }

    protected int isFinal_visited = -1;
    // Declared in Modifiers.jrag at line 228
 @SuppressWarnings({"unchecked", "cast"})     public boolean isFinal() {
        if(isFinal_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isFinal in class: ");
        isFinal_visited = boundariesCrossed;
        boolean isFinal_value = isFinal_compute();
        isFinal_visited = -1;
        return isFinal_value;
    }

    private boolean isFinal_compute() {  return getModifiers().isFinal() || hostType().isFinal() || isPrivate();  }

    protected int isSynchronized_visited = -1;
    // Declared in Modifiers.jrag at line 229
 @SuppressWarnings({"unchecked", "cast"})     public boolean isSynchronized() {
        if(isSynchronized_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isSynchronized in class: ");
        isSynchronized_visited = boundariesCrossed;
        boolean isSynchronized_value = isSynchronized_compute();
        isSynchronized_visited = -1;