expr.java

JDK1.4编译器前端

  		return constant().intValue() >= Short.MIN_VALUE && constant().intValue() <= Short.MAX_VALUE;
    if(t.isInt()) 
      return constant().intValue() >= Integer.MIN_VALUE && constant().intValue() <= Integer.MAX_VALUE;
	  return false;
  }

    protected int isConstant_visited = -1;
    // Declared in ConstantExpression.jrag at line 466
 @SuppressWarnings({"unchecked", "cast"})     public boolean isConstant() {
        if(isConstant_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isConstant in class: ");
        isConstant_visited = boundariesCrossed;
        boolean isConstant_value = isConstant_compute();
        isConstant_visited = -1;
        return isConstant_value;
    }

    private boolean isConstant_compute() {  return false;  }

    protected int isTrue_visited = -1;
    // Declared in ConstantExpression.jrag at line 495
 @SuppressWarnings({"unchecked", "cast"})     public boolean isTrue() {
        if(isTrue_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isTrue in class: ");
        isTrue_visited = boundariesCrossed;
        boolean isTrue_value = isTrue_compute();
        isTrue_visited = -1;
        return isTrue_value;
    }

    private boolean isTrue_compute() {  return isConstant() && type() instanceof BooleanType && constant().booleanValue();  }

    protected int isFalse_visited = -1;
    // Declared in ConstantExpression.jrag at line 496
 @SuppressWarnings({"unchecked", "cast"})     public boolean isFalse() {
        if(isFalse_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isFalse in class: ");
        isFalse_visited = boundariesCrossed;
        boolean isFalse_value = isFalse_compute();
        isFalse_visited = -1;
        return isFalse_value;
    }

    private boolean isFalse_compute() {  return isConstant() && type() instanceof BooleanType && !constant().booleanValue();  }

    protected int varDecl_visited = -1;
    // Declared in DefiniteAssignment.jrag at line 58
 @SuppressWarnings({"unchecked", "cast"})     public Variable varDecl() {
        if(varDecl_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: varDecl in class: ");
        varDecl_visited = boundariesCrossed;
        Variable varDecl_value = varDecl_compute();
        varDecl_visited = -1;
        return varDecl_value;
    }

    private Variable varDecl_compute() {  return null;  }

    protected java.util.Map isDAafterFalse_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 340
 @SuppressWarnings({"unchecked", "cast"})     public boolean isDAafterFalse(Variable v) {
        Object _parameters = v;
if(isDAafterFalse_Variable_visited == null) isDAafterFalse_Variable_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(isDAafterFalse_Variable_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: isDAafterFalse in class: ");
        isDAafterFalse_Variable_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean isDAafterFalse_Variable_value = isDAafterFalse_compute(v);
        isDAafterFalse_Variable_visited.remove(_parameters);
        return isDAafterFalse_Variable_value;
    }

    private boolean isDAafterFalse_compute(Variable v) {  return isTrue() || isDAbefore(v);  }

    protected java.util.Map isDAafterTrue_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 342
 @SuppressWarnings({"unchecked", "cast"})     public boolean isDAafterTrue(Variable v) {
        Object _parameters = v;
if(isDAafterTrue_Variable_visited == null) isDAafterTrue_Variable_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(isDAafterTrue_Variable_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: isDAafterTrue in class: ");
        isDAafterTrue_Variable_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean isDAafterTrue_Variable_value = isDAafterTrue_compute(v);
        isDAafterTrue_Variable_visited.remove(_parameters);
        return isDAafterTrue_Variable_value;
    }

    private boolean isDAafterTrue_compute(Variable v) {  return isFalse() || isDAbefore(v);  }

    protected java.util.Map isDAafter_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 345
 @SuppressWarnings({"unchecked", "cast"})     public boolean isDAafter(Variable v) {
        Object _parameters = v;
if(isDAafter_Variable_visited == null) isDAafter_Variable_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(isDAafter_Variable_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: isDAafter in class: ");
        isDAafter_Variable_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean isDAafter_Variable_value = isDAafter_compute(v);
        isDAafter_Variable_visited.remove(_parameters);
        return isDAafter_Variable_value;
    }

    private boolean isDAafter_compute(Variable v) {  return (isDAafterFalse(v) && isDAafterTrue(v)) || isDAbefore(v);  }

    protected java.util.Map isDUafterFalse_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 782
 @SuppressWarnings({"unchecked", "cast"})     public boolean isDUafterFalse(Variable v) {
        Object _parameters = v;
if(isDUafterFalse_Variable_visited == null) isDUafterFalse_Variable_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(isDUafterFalse_Variable_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: isDUafterFalse in class: ");
        isDUafterFalse_Variable_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean isDUafterFalse_Variable_value = isDUafterFalse_compute(v);
        isDUafterFalse_Variable_visited.remove(_parameters);
        return isDUafterFalse_Variable_value;
    }

    private boolean isDUafterFalse_compute(Variable v) {
    if(isTrue())
      return true;
    return isDUbefore(v);
  }

    protected java.util.Map isDUafterTrue_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 788
 @SuppressWarnings({"unchecked", "cast"})     public boolean isDUafterTrue(Variable v) {
        Object _parameters = v;
if(isDUafterTrue_Variable_visited == null) isDUafterTrue_Variable_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(isDUafterTrue_Variable_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: isDUafterTrue in class: ");
        isDUafterTrue_Variable_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean isDUafterTrue_Variable_value = isDUafterTrue_compute(v);
        isDUafterTrue_Variable_visited.remove(_parameters);
        return isDUafterTrue_Variable_value;
    }

    private boolean isDUafterTrue_compute(Variable v) {
    if(isFalse())
      return true;
    return isDUbefore(v);
  }

    protected java.util.Map isDUafter_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 798
 @SuppressWarnings({"unchecked", "cast"})     public boolean isDUafter(Variable v) {
        Object _parameters = v;
if(isDUafter_Variable_visited == null) isDUafter_Variable_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(isDUafter_Variable_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: isDUafter in class: ");
        isDUafter_Variable_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean isDUafter_Variable_value = isDUafter_compute(v);
        isDUafter_Variable_visited.remove(_parameters);
        return isDUafter_Variable_value;
    }

    private boolean isDUafter_compute(Variable v) {  return (isDUafterFalse(v) && isDUafterTrue(v)) || isDUbefore(v);  }

    protected java.util.Map mostSpecificConstructor_Collection_visited;
    // Declared in LookupConstructor.jrag at line 32
 @SuppressWarnings({"unchecked", "cast"})     public SimpleSet mostSpecificConstructor(Collection constructors) {
        Object _parameters = constructors;
if(mostSpecificConstructor_Collection_visited == null) mostSpecificConstructor_Collection_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(mostSpecificConstructor_Collection_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: mostSpecificConstructor in class: ");
        mostSpecificConstructor_Collection_visited.put(_parameters, new Integer(boundariesCrossed));
        SimpleSet mostSpecificConstructor_Collection_value = mostSpecificConstructor_compute(constructors);
        mostSpecificConstructor_Collection_visited.remove(_parameters);
        return mostSpecificConstructor_Collection_value;
    }

    private SimpleSet mostSpecificConstructor_compute(Collection constructors) {
    SimpleSet maxSpecific = SimpleSet.emptySet;
    for(Iterator iter = constructors.iterator(); iter.hasNext(); ) {
      ConstructorDecl decl = (ConstructorDecl)iter.next();
      if(applicableAndAccessible(decl)) {
        if(maxSpecific.isEmpty())
          maxSpecific = maxSpecific.add(decl);
        else {
          if(decl.moreSpecificThan((ConstructorDecl)maxSpecific.iterator().next()))
            maxSpecific = SimpleSet.emptySet.add(decl);
          else if(!((ConstructorDecl)maxSpecific.iterator().next()).moreSpecificThan(decl))
            maxSpecific = maxSpecific.add(decl);
        }
      }
    }
    return maxSpecific;
  }

    protected java.util.Map applicableAndAccessible_ConstructorDecl_visited;
    // Declared in LookupConstructor.jrag at line 50
 @SuppressWarnings({"unchecked", "cast"})     public boolean applicableAndAccessible(ConstructorDecl decl) {
        Object _parameters = decl;
if(applicableAndAccessible_ConstructorDecl_visited == null) applicableAndAccessible_ConstructorDecl_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(applicableAndAccessible_ConstructorDecl_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: applicableAndAccessible in class: ");
        applicableAndAccessible_ConstructorDecl_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean applicableAndAccessible_ConstructorDecl_value = applicableAndAccessible_compute(decl);
        applicableAndAccessible_ConstructorDecl_visited.remove(_parameters);
        return applicableAndAccessible_ConstructorDecl_value;
    }

    private boolean applicableAndAccessible_compute(ConstructorDecl decl) {  return false;  }

    protected java.util.Map hasQualifiedPackage_String_visited;
    // Declared in LookupType.jrag at line 83
 @SuppressWarnings({"unchecked", "cast"})     public boolean hasQualifiedPackage(String packageName) {
        Object _parameters = packageName;
if(hasQualifiedPackage_String_visited == null) hasQualifiedPackage_String_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(hasQualifiedPackage_String_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: hasQualifiedPackage in class: ");
        hasQualifiedPackage_String_visited.put(_parameters, new Integer(boundariesCrossed));
        boolean hasQualifiedPackage_String_value = hasQualifiedPackage_compute(packageName);
        hasQualifiedPackage_String_visited.remove(_parameters);
        return hasQualifiedPackage_String_value;
    }

    private boolean hasQualifiedPackage_compute(String packageName) {  return false;  }

    protected java.util.Map qualifiedLookupType_String_visited;
    // Declared in LookupType.jrag at line 342
 @SuppressWarnings({"unchecked", "cast"})     public SimpleSet qualifiedLookupType(String name) {
        Object _parameters = name;
if(qualifiedLookupType_String_visited == null) qualifiedLookupType_String_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(qualifiedLookupType_String_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: qualifiedLookupType in class: ");
        qualifiedLookupType_String_visited.put(_parameters, new Integer(boundariesCrossed));
        SimpleSet qualifiedLookupType_String_value = qualifiedLookupType_compute(name);
        qualifiedLookupType_String_visited.remove(_parameters);
        return qualifiedLookupType_String_value;
    }

    private SimpleSet qualifiedLookupType_compute(String name) {  return keepAccessibleTypes(type().memberTypes(name));  }

    protected java.util.Map qualifiedLookupVariable_String_visited;
    // Declared in LookupVariable.jrag at line 146
 @SuppressWarnings({"unchecked", "cast"})     public SimpleSet qualifiedLookupVariable(String name) {
        Object _parameters = name;
if(qualifiedLookupVariable_String_visited == null) qualifiedLookupVariable_String_visited = new java.util.HashMap(4);
        if(new Integer(boundariesCrossed).equals(qualifiedLookupVariable_String_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: qualifiedLookupVariable in class: ");
        qualifiedLookupVariable_String_visited.put(_parameters, new Integer(boundariesCrossed));
        SimpleSet qualifiedLookupVariable_String_value = qualifiedLookupVariable_compute(name);
        qualifiedLookupVariable_String_visited.remove(_parameters);
        return qualifiedLookupVariable_String_value;
    }

    private SimpleSet qualifiedLookupVariable_compute(String name) {
    if(type().accessibleFrom(hostType()))
      return keepAccessibleFields(type().memberFields(name));
    return SimpleSet.emptySet;
  }

    protected int packageName_visited = -1;
    // Declared in QualifiedNames.jrag at line 25
 @SuppressWarnings({"unchecked", "cast"})     public String packageName() {
        if(packageName_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: packageName in class: ");
        packageName_visited = boundariesCrossed;
        String packageName_value = packageName_compute();
        packageName_visited = -1;
        return packageName_value;
    }

    private String packageName_compute() {  return "";  }

    protected int typeName_visited = -1;
    // Declared in QualifiedNames.jrag at line 62
 @SuppressWarnings({"unchecked", "cast"})     public String typeName() {
        if(typeName_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: typeName in class: ");
        typeName_visited = boundariesCrossed;
        String typeName_value = typeName_compute();
        typeName_visited = -1;
        return typeName_value;
    }

    private String typeName_compute() {  return "";  }

    protected int isTypeAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 13
 @SuppressWarnings({"unchecked", "cast"})     public boolean isTypeAccess() {
        if(isTypeAccess_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isTypeAccess in class: ");
        isTypeAccess_visited = boundariesCrossed;
        boolean isTypeAccess_value = isTypeAccess_compute();
        isTypeAccess_visited = -1;
        return isTypeAccess_value;
    }