abstractdot.java

JDK1.4编译器前端

 @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 isDAafter(v);  }

    protected java.util.Map isDAafter_Variable_visited;
    protected java.util.Map isDAafter_Variable_values;
    // Declared in DefiniteAssignment.jrag at line 357
 @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(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
        if(isDAafter_Variable_values.containsKey(_parameters))
            return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
        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));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        boolean isDAafter_Variable_value = isDAafter_compute(v);
        if(isFinal && num == boundariesCrossed)
            isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value));
        isDAafter_Variable_visited.remove(_parameters);
        return isDAafter_Variable_value;
    }

    private boolean isDAafter_compute(Variable v) {  return lastAccess().isDAafter(v);  }

    protected java.util.Map isDUafterTrue_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 794
 @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) {  return isDUafter(v);  }

    protected java.util.Map isDUafterFalse_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 795
 @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) {  return isDUafter(v);  }

    protected java.util.Map isDUafter_Variable_visited;
    protected java.util.Map isDUafter_Variable_values;
    // Declared in DefiniteAssignment.jrag at line 839
 @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(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
        if(isDUafter_Variable_values.containsKey(_parameters))
            return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
        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));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        boolean isDUafter_Variable_value = isDUafter_compute(v);
        if(isFinal && num == boundariesCrossed)
            isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value));
        isDUafter_Variable_visited.remove(_parameters);
        return isDUafter_Variable_value;
    }

    private boolean isDUafter_compute(Variable v) {  return lastAccess().isDUafter(v);  }

    protected int typeName_visited = -1;
    // Declared in QualifiedNames.jrag at line 63
 @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 lastAccess().typeName();  }

    protected int isTypeAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 15
 @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;
    }

    private boolean isTypeAccess_compute() {  return getRight().isTypeAccess();  }

    protected int isMethodAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 18
 @SuppressWarnings({"unchecked", "cast"})     public boolean isMethodAccess() {
        if(isMethodAccess_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isMethodAccess in class: ");
        isMethodAccess_visited = boundariesCrossed;
        boolean isMethodAccess_value = isMethodAccess_compute();
        isMethodAccess_visited = -1;
        return isMethodAccess_value;
    }

    private boolean isMethodAccess_compute() {  return getRight().isMethodAccess();  }

    protected int isFieldAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 22
 @SuppressWarnings({"unchecked", "cast"})     public boolean isFieldAccess() {
        if(isFieldAccess_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isFieldAccess in class: ");
        isFieldAccess_visited = boundariesCrossed;
        boolean isFieldAccess_value = isFieldAccess_compute();
        isFieldAccess_visited = -1;
        return isFieldAccess_value;
    }

    private boolean isFieldAccess_compute() {  return getRight().isFieldAccess();  }

    protected int isSuperAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 26
 @SuppressWarnings({"unchecked", "cast"})     public boolean isSuperAccess() {
        if(isSuperAccess_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isSuperAccess in class: ");
        isSuperAccess_visited = boundariesCrossed;
        boolean isSuperAccess_value = isSuperAccess_compute();
        isSuperAccess_visited = -1;
        return isSuperAccess_value;
    }

    private boolean isSuperAccess_compute() {  return getRight().isSuperAccess();  }

    protected int isThisAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 32
 @SuppressWarnings({"unchecked", "cast"})     public boolean isThisAccess() {
        if(isThisAccess_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isThisAccess in class: ");
        isThisAccess_visited = boundariesCrossed;
        boolean isThisAccess_value = isThisAccess_compute();
        isThisAccess_visited = -1;
        return isThisAccess_value;
    }

    private boolean isThisAccess_compute() {  return getRight().isThisAccess();  }

    protected int isPackageAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 38
 @SuppressWarnings({"unchecked", "cast"})     public boolean isPackageAccess() {
        if(isPackageAccess_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isPackageAccess in class: ");
        isPackageAccess_visited = boundariesCrossed;
        boolean isPackageAccess_value = isPackageAccess_compute();
        isPackageAccess_visited = -1;
        return isPackageAccess_value;
    }

    private boolean isPackageAccess_compute() {  return getRight().isPackageAccess();  }

    protected int isArrayAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 42
 @SuppressWarnings({"unchecked", "cast"})     public boolean isArrayAccess() {
        if(isArrayAccess_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isArrayAccess in class: ");
        isArrayAccess_visited = boundariesCrossed;
        boolean isArrayAccess_value = isArrayAccess_compute();
        isArrayAccess_visited = -1;
        return isArrayAccess_value;
    }

    private boolean isArrayAccess_compute() {  return getRight().isArrayAccess();  }

    protected int isClassAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 46
 @SuppressWarnings({"unchecked", "cast"})     public boolean isClassAccess() {
        if(isClassAccess_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isClassAccess in class: ");
        isClassAccess_visited = boundariesCrossed;
        boolean isClassAccess_value = isClassAccess_compute();
        isClassAccess_visited = -1;
        return isClassAccess_value;
    }

    private boolean isClassAccess_compute() {  return getRight().isClassAccess();  }

    protected int isSuperConstructorAccess_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 50
 @SuppressWarnings({"unchecked", "cast"})     public boolean isSuperConstructorAccess() {
        if(isSuperConstructorAccess_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isSuperConstructorAccess in class: ");
        isSuperConstructorAccess_visited = boundariesCrossed;
        boolean isSuperConstructorAccess_value = isSuperConstructorAccess_compute();
        isSuperConstructorAccess_visited = -1;
        return isSuperConstructorAccess_value;
    }

    private boolean isSuperConstructorAccess_compute() {  return getRight().isSuperConstructorAccess();  }

    protected int isQualified_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 59
 @SuppressWarnings({"unchecked", "cast"})     public boolean isQualified() {
        if(isQualified_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isQualified in class: ");
        isQualified_visited = boundariesCrossed;
        boolean isQualified_value = isQualified_compute();
        isQualified_visited = -1;
        return isQualified_value;
    }

    private boolean isQualified_compute() {  return hasParentDot();  }

    protected int leftSide_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 63
 @SuppressWarnings({"unchecked", "cast"})     public Expr leftSide() {
        if(leftSide_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: leftSide in class: ");
        leftSide_visited = boundariesCrossed;
        Expr leftSide_value = leftSide_compute();
        leftSide_visited = -1;
        return leftSide_value;
    }

    private Expr leftSide_compute() {  return getLeft();  }

    protected int rightSide_visited = -1;
    // Declared in ResolveAmbiguousNames.jrag at line 64
 @SuppressWarnings({"unchecked", "cast"})     public Access rightSide() {
        if(rightSide_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: rightSide in class: ");
        rightSide_visited = boundariesCrossed;
        Access rightSide_value = rightSide_compute();
        rightSide_visited = -1;
        return rightSide_value;
    }