modifiers.java

JDK1.4编译器前端

package AST;
import java.util.HashSet;import java.util.LinkedHashSet;import java.io.FileNotFoundException;import java.io.File;import java.util.*;import beaver.*;import java.util.ArrayList;import java.util.zip.*;import java.io.*;



public class Modifiers extends ASTNode<ASTNode> implements Cloneable {
    public void flushCache() {
        super.flushCache();
        isExternal_visited = -1;
        isExternal_computed = false;
        isPublic_visited = -1;
        isPublic_computed = false;
        isPrivate_visited = -1;
        isPrivate_computed = false;
        isProtected_visited = -1;
        isProtected_computed = false;
        isStatic_visited = -1;
        isStatic_computed = false;
        isFinal_visited = -1;
        isFinal_computed = false;
        isAbstract_visited = -1;
        isAbstract_computed = false;
        isVolatile_visited = -1;
        isVolatile_computed = false;
        isTransient_visited = -1;
        isTransient_computed = false;
        isStrictfp_visited = -1;
        isStrictfp_computed = false;
        isSynchronized_visited = -1;
        isSynchronized_computed = false;
        isNative_visited = -1;
        isNative_computed = false;
        isSynthetic_visited = -1;
        isSynthetic_computed = false;
        numProtectionModifiers_visited = -1;
        numCompletenessModifiers_visited = -1;
        numModifier_String_visited = new java.util.HashMap(4);
        numModifier_String_values = null;
        mayBePublic_visited = -1;
        mayBePrivate_visited = -1;
        mayBeProtected_visited = -1;
        mayBeStatic_visited = -1;
        mayBeFinal_visited = -1;
        mayBeAbstract_visited = -1;
        mayBeVolatile_visited = -1;
        mayBeTransient_visited = -1;
        mayBeStrictfp_visited = -1;
        mayBeSynchronized_visited = -1;
        mayBeNative_visited = -1;
    }
     @SuppressWarnings({"unchecked", "cast"})  public Modifiers clone() throws CloneNotSupportedException {
        Modifiers node = (Modifiers)super.clone();
        node.isExternal_visited = -1;
        node.isExternal_computed = false;
        node.isPublic_visited = -1;
        node.isPublic_computed = false;
        node.isPrivate_visited = -1;
        node.isPrivate_computed = false;
        node.isProtected_visited = -1;
        node.isProtected_computed = false;
        node.isStatic_visited = -1;
        node.isStatic_computed = false;
        node.isFinal_visited = -1;
        node.isFinal_computed = false;
        node.isAbstract_visited = -1;
        node.isAbstract_computed = false;
        node.isVolatile_visited = -1;
        node.isVolatile_computed = false;
        node.isTransient_visited = -1;
        node.isTransient_computed = false;
        node.isStrictfp_visited = -1;
        node.isStrictfp_computed = false;
        node.isSynchronized_visited = -1;
        node.isSynchronized_computed = false;
        node.isNative_visited = -1;
        node.isNative_computed = false;
        node.isSynthetic_visited = -1;
        node.isSynthetic_computed = false;
        node.numProtectionModifiers_visited = -1;
        node.numCompletenessModifiers_visited = -1;
        node.numModifier_String_visited = new java.util.HashMap(4);
        node.numModifier_String_values = null;
        node.mayBePublic_visited = -1;
        node.mayBePrivate_visited = -1;
        node.mayBeProtected_visited = -1;
        node.mayBeStatic_visited = -1;
        node.mayBeFinal_visited = -1;
        node.mayBeAbstract_visited = -1;
        node.mayBeVolatile_visited = -1;
        node.mayBeTransient_visited = -1;
        node.mayBeStrictfp_visited = -1;
        node.mayBeSynchronized_visited = -1;
        node.mayBeNative_visited = -1;
        node.in$Circle(false);
        node.is$Final(false);
    return node;
    }
     @SuppressWarnings({"unchecked", "cast"})  public Modifiers copy() {
      try {
          Modifiers node = (Modifiers)clone();
          if(children != null) node.children = (ASTNode[])children.clone();
          return node;
      } catch (CloneNotSupportedException e) {
      }
      System.err.println("Error: Could not clone node of type " + getClass().getName() + "!");
      return null;
    }
     @SuppressWarnings({"unchecked", "cast"})  public Modifiers fullCopy() {
        Modifiers res = (Modifiers)copy();
        for(int i = 0; i < getNumChildNoTransform(); i++) {
          ASTNode node = getChildNoTransform(i);
          if(node != null) node = node.fullCopy();
          res.setChild(node, i);
        }
        return res;
    }
    // Declared in Modifiers.jrag at line 312


  // 8.4.3
  public void checkModifiers() {
    super.checkModifiers();
    if(numProtectionModifiers() > 1)
      error("only one public, protected, private allowed");
    if(numModifier("static") > 1)
      error("only one static allowed");
    // 8.4.3.1
    // 8.4.3.2
    // 8.1.1.2
    if(numCompletenessModifiers() > 1)
      error("only one of final, abstract, volatile allowed");
    if(numModifier("synchronized") > 1)
      error("only one synchronized allowed");
    if(numModifier("transient") > 1)
      error("only one transient allowed");
    if(numModifier("native") > 1)
      error("only one native allowed");
    if(numModifier("strictfp") > 1)
      error("only one strictfp allowed");

    if(isPublic() && !mayBePublic())
      error("modifier public not allowed in this context");
    if(isPrivate() && !mayBePrivate())
      error("modifier private not allowed in this context");
    if(isProtected() && !mayBeProtected())
      error("modifier protected not allowed in this context");
    if(isStatic() && !mayBeStatic())
      error("modifier static not allowed in this context");
    if(isFinal() && !mayBeFinal())
      error("modifier final not allowed in this context");
    if(isAbstract() && !mayBeAbstract())
      error("modifier abstract not allowed in this context");
    if(isVolatile() && !mayBeVolatile())
      error("modifier volatile not allowed in this context");
    if(isTransient() && !mayBeTransient())
      error("modifier transient not allowed in this context");
    if(isStrictfp() && !mayBeStrictfp())
      error("modifier strictfp not allowed in this context");
    if(isSynchronized() && !mayBeSynchronized())
      error("modifier synchronized not allowed in this context");
    if(isNative() && !mayBeNative())
      error("modifier native not allowed in this context");
  }

    // Declared in PrettyPrint.jadd at line 451


  public void toString(StringBuffer s) {
    for(int i = 0; i < getNumModifier(); i++) {
      getModifier(i).toString(s);
      s.append(" ");
    }
  }

    // Declared in java.ast at line 3
    // Declared in java.ast line 193

    public Modifiers() {
        super();

        setChild(new List(), 0);

    }

    // Declared in java.ast at line 11


    // Declared in java.ast line 193
    public Modifiers(List<Modifier> p0) {
        setChild(p0, 0);
    }

    // Declared in java.ast at line 15


  protected int numChildren() {
    return 1;
  }

    // Declared in java.ast at line 18

  public boolean mayHaveRewrite() { return false; }

    // Declared in java.ast at line 2
    // Declared in java.ast line 193
    public void setModifierList(List<Modifier> list) {
        setChild(list, 0);
    }

    // Declared in java.ast at line 6


    private int getNumModifier = 0;

    // Declared in java.ast at line 7

    public int getNumModifier() {
        return getModifierList().getNumChild();
    }

    // Declared in java.ast at line 11


     @SuppressWarnings({"unchecked", "cast"})  public Modifier getModifier(int i) {
        return (Modifier)getModifierList().getChild(i);
    }

    // Declared in java.ast at line 15


    public void addModifier(Modifier node) {
        List<Modifier> list = getModifierList();
        list.addChild(node);
    }

    // Declared in java.ast at line 20


    public void setModifier(Modifier node, int i) {
        List<Modifier> list = getModifierList();
        list.setChild(node, i);
    }

    // Declared in java.ast at line 24

    public List<Modifier> getModifiers() {
        return getModifierList();
    }

    // Declared in java.ast at line 27

    public List<Modifier> getModifiersNoTransform() {
        return getModifierListNoTransform();
    }

    // Declared in java.ast at line 31


     @SuppressWarnings({"unchecked", "cast"})  public List<Modifier> getModifierList() {
        return (List<Modifier>)getChild(0);
    }

    // Declared in java.ast at line 35


     @SuppressWarnings({"unchecked", "cast"})  public List<Modifier> getModifierListNoTransform() {
        return (List<Modifier>)getChildNoTransform(0);
    }

    protected int isExternal_visited = -1;
    protected boolean isExternal_computed = false;
    protected boolean isExternal_value;
    // Declared in GOP.jrag at line 349
 @SuppressWarnings({"unchecked", "cast"})     public boolean isExternal() {
        if(isExternal_computed)
            return isExternal_value;
        if(isExternal_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isExternal in class: ");
        isExternal_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        isExternal_value = isExternal_compute();
        if(isFinal && num == boundariesCrossed)
            isExternal_computed = true;
        isExternal_visited = -1;
        return isExternal_value;
    }

    private boolean isExternal_compute() {  return numModifier("external") != 0;  }

    protected int isPublic_visited = -1;
    protected boolean isPublic_computed = false;
    protected boolean isPublic_value;
    // Declared in Modifiers.jrag at line 368
 @SuppressWarnings({"unchecked", "cast"})     public boolean isPublic() {
        if(isPublic_computed)
            return isPublic_value;
        if(isPublic_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isPublic in class: ");
        isPublic_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        isPublic_value = isPublic_compute();
        if(isFinal && num == boundariesCrossed)
            isPublic_computed = true;
        isPublic_visited = -1;
        return isPublic_value;
    }

    private boolean isPublic_compute() {  return numModifier("public") != 0;  }

    protected int isPrivate_visited = -1;
    protected boolean isPrivate_computed = false;
    protected boolean isPrivate_value;
    // Declared in Modifiers.jrag at line 369
 @SuppressWarnings({"unchecked", "cast"})     public boolean isPrivate() {
        if(isPrivate_computed)
            return isPrivate_value;
        if(isPrivate_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isPrivate in class: ");
        isPrivate_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        isPrivate_value = isPrivate_compute();
        if(isFinal && num == boundariesCrossed)
            isPrivate_computed = true;
        isPrivate_visited = -1;
        return isPrivate_value;
    }

    private boolean isPrivate_compute() {  return numModifier("private") != 0;  }

    protected int isProtected_visited = -1;
    protected boolean isProtected_computed = false;
    protected boolean isProtected_value;
    // Declared in Modifiers.jrag at line 370
 @SuppressWarnings({"unchecked", "cast"})     public boolean isProtected() {
        if(isProtected_computed)
            return isProtected_value;
        if(isProtected_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: isProtected in class: ");
        isProtected_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        isProtected_value = isProtected_compute();
        if(isFinal && num == boundariesCrossed)
            isProtected_computed = true;
        isProtected_visited = -1;
        return isProtected_value;
    }

    private boolean isProtected_compute() {  return numModifier("protected") != 0;  }

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