program.java

JDK1.4编译器前端

    protected TypeDecl typeShort_value;
    // Declared in LookupType.jrag at line 24
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl typeShort() {
        if(typeShort_computed)
            return typeShort_value;
        if(typeShort_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeShort in class: ");
        typeShort_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        typeShort_value = typeShort_compute();
        if(isFinal && num == boundariesCrossed)
            typeShort_computed = true;
        typeShort_visited = -1;
        return typeShort_value;
    }

    private TypeDecl typeShort_compute() {  return lookupType(PRIMITIVE_PACKAGE_NAME , "short");  }

    protected int typeChar_visited = -1;
    protected boolean typeChar_computed = false;
    protected TypeDecl typeChar_value;
    // Declared in LookupType.jrag at line 25
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl typeChar() {
        if(typeChar_computed)
            return typeChar_value;
        if(typeChar_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeChar in class: ");
        typeChar_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        typeChar_value = typeChar_compute();
        if(isFinal && num == boundariesCrossed)
            typeChar_computed = true;
        typeChar_visited = -1;
        return typeChar_value;
    }

    private TypeDecl typeChar_compute() {  return lookupType(PRIMITIVE_PACKAGE_NAME , "char");  }

    protected int typeInt_visited = -1;
    protected boolean typeInt_computed = false;
    protected TypeDecl typeInt_value;
    // Declared in LookupType.jrag at line 26
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl typeInt() {
        if(typeInt_computed)
            return typeInt_value;
        if(typeInt_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeInt in class: ");
        typeInt_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        typeInt_value = typeInt_compute();
        if(isFinal && num == boundariesCrossed)
            typeInt_computed = true;
        typeInt_visited = -1;
        return typeInt_value;
    }

    private TypeDecl typeInt_compute() {  return lookupType(PRIMITIVE_PACKAGE_NAME , "int");  }

    protected int typeLong_visited = -1;
    protected boolean typeLong_computed = false;
    protected TypeDecl typeLong_value;
    // Declared in LookupType.jrag at line 27
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl typeLong() {
        if(typeLong_computed)
            return typeLong_value;
        if(typeLong_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeLong in class: ");
        typeLong_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        typeLong_value = typeLong_compute();
        if(isFinal && num == boundariesCrossed)
            typeLong_computed = true;
        typeLong_visited = -1;
        return typeLong_value;
    }

    private TypeDecl typeLong_compute() {  return lookupType(PRIMITIVE_PACKAGE_NAME , "long");  }

    protected int typeFloat_visited = -1;
    protected boolean typeFloat_computed = false;
    protected TypeDecl typeFloat_value;
    // Declared in LookupType.jrag at line 28
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl typeFloat() {
        if(typeFloat_computed)
            return typeFloat_value;
        if(typeFloat_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeFloat in class: ");
        typeFloat_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        typeFloat_value = typeFloat_compute();
        if(isFinal && num == boundariesCrossed)
            typeFloat_computed = true;
        typeFloat_visited = -1;
        return typeFloat_value;
    }

    private TypeDecl typeFloat_compute() {  return lookupType(PRIMITIVE_PACKAGE_NAME , "float");  }

    protected int typeDouble_visited = -1;
    protected boolean typeDouble_computed = false;
    protected TypeDecl typeDouble_value;
    // Declared in LookupType.jrag at line 29
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl typeDouble() {
        if(typeDouble_computed)
            return typeDouble_value;
        if(typeDouble_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeDouble in class: ");
        typeDouble_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        typeDouble_value = typeDouble_compute();
        if(isFinal && num == boundariesCrossed)
            typeDouble_computed = true;
        typeDouble_visited = -1;
        return typeDouble_value;
    }

    private TypeDecl typeDouble_compute() {  return lookupType(PRIMITIVE_PACKAGE_NAME , "double");  }

    protected int typeString_visited = -1;
    protected boolean typeString_computed = false;
    protected TypeDecl typeString_value;
    // Declared in LookupType.jrag at line 30
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl typeString() {
        if(typeString_computed)
            return typeString_value;
        if(typeString_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeString in class: ");
        typeString_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        typeString_value = typeString_compute();
        if(isFinal && num == boundariesCrossed)
            typeString_computed = true;
        typeString_visited = -1;
        return typeString_value;
    }

    private TypeDecl typeString_compute() {  return lookupType("java.lang", "String");  }

    protected int typeVoid_visited = -1;
    protected boolean typeVoid_computed = false;
    protected TypeDecl typeVoid_value;
    // Declared in LookupType.jrag at line 41
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl typeVoid() {
        if(typeVoid_computed)
            return typeVoid_value;
        if(typeVoid_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeVoid in class: ");
        typeVoid_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        typeVoid_value = typeVoid_compute();
        if(isFinal && num == boundariesCrossed)
            typeVoid_computed = true;
        typeVoid_visited = -1;
        return typeVoid_value;
    }

    private TypeDecl typeVoid_compute() {  return lookupType(PRIMITIVE_PACKAGE_NAME, "void");  }

    protected int typeNull_visited = -1;
    protected boolean typeNull_computed = false;
    protected TypeDecl typeNull_value;
    // Declared in LookupType.jrag at line 43
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl typeNull() {
        if(typeNull_computed)
            return typeNull_value;
        if(typeNull_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeNull in class: ");
        typeNull_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        typeNull_value = typeNull_compute();
        if(isFinal && num == boundariesCrossed)
            typeNull_computed = true;
        typeNull_visited = -1;
        return typeNull_value;
    }

    private TypeDecl typeNull_compute() {  return lookupType(PRIMITIVE_PACKAGE_NAME, "null");  }

    protected int unknownType_visited = -1;
    protected boolean unknownType_computed = false;
    protected TypeDecl unknownType_value;
    // Declared in LookupType.jrag at line 46
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl unknownType() {
        if(unknownType_computed)
            return unknownType_value;
        if(unknownType_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: unknownType in class: ");
        unknownType_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        unknownType_value = unknownType_compute();
        if(isFinal && num == boundariesCrossed)
            unknownType_computed = true;
        unknownType_visited = -1;
        return unknownType_value;
    }

    private TypeDecl unknownType_compute() {  return lookupType(PRIMITIVE_PACKAGE_NAME, "Unknown");  }

    protected java.util.Map hasPackage_String_visited;
    protected java.util.Map hasPackage_String_values;
    // Declared in LookupType.jrag at line 77
 @SuppressWarnings({"unchecked", "cast"})     public boolean hasPackage(String packageName) {
        Object _parameters = packageName;
if(hasPackage_String_visited == null) hasPackage_String_visited = new java.util.HashMap(4);
if(hasPackage_String_values == null) hasPackage_String_values = new java.util.HashMap(4);
        if(hasPackage_String_values.containsKey(_parameters))
            return ((Boolean)hasPackage_String_values.get(_parameters)).booleanValue();
        if(new Integer(boundariesCrossed).equals(hasPackage_String_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: hasPackage in class: ");
        hasPackage_String_visited.put(_parameters, new Integer(boundariesCrossed));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        boolean hasPackage_String_value = hasPackage_compute(packageName);
        if(isFinal && num == boundariesCrossed)
            hasPackage_String_values.put(_parameters, Boolean.valueOf(hasPackage_String_value));
        hasPackage_String_visited.remove(_parameters);
        return hasPackage_String_value;
    }

    private boolean hasPackage_compute(String packageName) {
    return isPackage(packageName);
  }

    protected java.util.Map lookupType_String_String_visited;
    protected java.util.Map lookupType_String_String_values;
    // Declared in LookupType.jrag at line 105
 @SuppressWarnings({"unchecked", "cast"})     public TypeDecl lookupType(String packageName, String typeName) {
        java.util.List _parameters = new java.util.ArrayList(2);
        _parameters.add(packageName);
        _parameters.add(typeName);
if(lookupType_String_String_visited == null) lookupType_String_String_visited = new java.util.HashMap(4);
if(lookupType_String_String_values == null) lookupType_String_String_values = new java.util.HashMap(4);
        if(lookupType_String_String_values.containsKey(_parameters))
            return (TypeDecl)lookupType_String_String_values.get(_parameters);
        if(new Integer(boundariesCrossed).equals(lookupType_String_String_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: lookupType in class: ");
        lookupType_String_String_visited.put(_parameters, new Integer(boundariesCrossed));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        TypeDecl lookupType_String_String_value = lookupType_compute(packageName, typeName);
        if(isFinal && num == boundariesCrossed)
            lookupType_String_String_values.put(_parameters, lookupType_String_String_value);
        lookupType_String_String_visited.remove(_parameters);
        return lookupType_String_String_value;
    }

    private TypeDecl lookupType_compute(String packageName, String typeName) {
    addPrimitiveTypes();
    String fullName = packageName.equals("") ? typeName : packageName + "." + typeName;
    for(int i = 0; i < getNumCompilationUnit(); i++) {
      for(int j = 0; j < getCompilationUnit(i).getNumTypeDecl(); j++) {
        TypeDecl type = getCompilationUnit(i).getTypeDecl(j);
        if(type.fullName().equals(fullName)) {
          return type;
        }
      }
    }
    
    CompilationUnit u = getCompilationUnit(fullName);
    if(u != null) {
      addCompilationUnit(u);
      getCompilationUnit(getNumCompilationUnit()-1);
      for(int j = 0; j < u.getNumTypeDecl(); j++) {
        if(u.getTypeDecl(j).name().equals(typeName)) {
          return u.getTypeDecl(j);
        }
      }
      throw new Error("No type named " + typeName + " in file " + fullName + ", " + u.pathName() + ", " + u.relativeName());
    }
    return null;
  }

    protected int unknownConstructor_visited = -1;
    protected boolean unknownConstructor_computed = false;
    protected ConstructorDecl unknownConstructor_value;
    // Declared in TypeAnalysis.jrag at line 246
 @SuppressWarnings({"unchecked", "cast"})     public ConstructorDecl unknownConstructor() {
        if(unknownConstructor_computed)
            return unknownConstructor_value;
        if(unknownConstructor_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: unknownConstructor in class: ");
        unknownConstructor_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        unknownConstructor_value = unknownConstructor_compute();
        if(isFinal && num == boundariesCrossed)
            unknownConstructor_computed = true;
        unknownConstructor_visited = -1;
        return unknownConstructor_value;
    }

    private ConstructorDecl unknownConstructor_compute() {
    return (ConstructorDecl)unknownType().constructors().iterator().next();
  }

    // Declared in Modifiers.jrag at line 290
    public boolean Define_boolean_mayBePrivate(ASTNode caller, ASTNode child) {
        if(true) {
      int childIndex = this.getIndexOfChild(caller);
            return false;
        }
        if(getParent() == null) throw new RuntimeException("Trying to evaluate attribute in subtree not attached to main tree");        return getParent().Define_boolean_mayBePrivate(this, caller);
    }

    // Declared in LookupType.jrag at line 47
    public TypeDecl Define_TypeDecl_unknownType(ASTNode caller, ASTNode child) {
        if(true) {
      int childIndex = this.getIndexOfChild(caller);
            return unknownType();
        }
        if(getParent() == null) throw new RuntimeException("Trying to evaluate attribute in subtree not attached to main tree");        return getParent().Define_TypeDecl_unknownType(this, caller);
    }

    // Declared in LookupType.jrag at line 20
    public TypeDecl Define_TypeDecl_typeSerializable(ASTNode caller, ASTNode child) {
        if(true) {
      int childIndex = this.getIndexOfChild(caller);
            return typeSerializable();
        }
        if(getParent() == null) throw new RuntimeException("Trying to evaluate attribute in subtree not attached to main tree");        return getParent().Define_TypeDecl_typeSerializable(this, caller);
    }

    // Declared in ExceptionHandling.jrag at line 114
    public boolean Define_boolean_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
        if(true) { 
   int childIndex = this.getIndexOfChild(caller);
{
    throw new Error("Operation handlesException not supported");
  }