forstmt.java

JDK1.4编译器前端

    // Declared in java.ast at line 2
    // Declared in java.ast line 213
    public void setUpdateStmtList(List<Stmt> list) {
        setChild(list, 2);
    }

    // Declared in java.ast at line 6


    private int getNumUpdateStmt = 0;

    // Declared in java.ast at line 7

    public int getNumUpdateStmt() {
        return getUpdateStmtList().getNumChild();
    }

    // Declared in java.ast at line 11


     @SuppressWarnings({"unchecked", "cast"})  public Stmt getUpdateStmt(int i) {
        return (Stmt)getUpdateStmtList().getChild(i);
    }

    // Declared in java.ast at line 15


    public void addUpdateStmt(Stmt node) {
        List<Stmt> list = getUpdateStmtList();
        list.addChild(node);
    }

    // Declared in java.ast at line 20


    public void setUpdateStmt(Stmt node, int i) {
        List<Stmt> list = getUpdateStmtList();
        list.setChild(node, i);
    }

    // Declared in java.ast at line 24

    public List<Stmt> getUpdateStmts() {
        return getUpdateStmtList();
    }

    // Declared in java.ast at line 27

    public List<Stmt> getUpdateStmtsNoTransform() {
        return getUpdateStmtListNoTransform();
    }

    // Declared in java.ast at line 31


     @SuppressWarnings({"unchecked", "cast"})  public List<Stmt> getUpdateStmtList() {
        return (List<Stmt>)getChild(2);
    }

    // Declared in java.ast at line 35


     @SuppressWarnings({"unchecked", "cast"})  public List<Stmt> getUpdateStmtListNoTransform() {
        return (List<Stmt>)getChildNoTransform(2);
    }

    // Declared in java.ast at line 2
    // Declared in java.ast line 213
    public void setStmt(Stmt node) {
        setChild(node, 3);
    }

    // Declared in java.ast at line 5

    public Stmt getStmt() {
        return (Stmt)getChild(3);
    }

    // Declared in java.ast at line 9


    public Stmt getStmtNoTransform() {
        return (Stmt)getChildNoTransform(3);
    }

    protected java.util.Map targetOf_ContinueStmt_visited;
    protected java.util.Map targetOf_ContinueStmt_values;
    // Declared in BranchTarget.jrag at line 72
 @SuppressWarnings({"unchecked", "cast"})     public boolean targetOf(ContinueStmt stmt) {
        Object _parameters = stmt;
if(targetOf_ContinueStmt_visited == null) targetOf_ContinueStmt_visited = new java.util.HashMap(4);
if(targetOf_ContinueStmt_values == null) targetOf_ContinueStmt_values = new java.util.HashMap(4);
        if(targetOf_ContinueStmt_values.containsKey(_parameters))
            return ((Boolean)targetOf_ContinueStmt_values.get(_parameters)).booleanValue();
        if(new Integer(boundariesCrossed).equals(targetOf_ContinueStmt_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: targetOf in class: ");
        targetOf_ContinueStmt_visited.put(_parameters, new Integer(boundariesCrossed));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        boolean targetOf_ContinueStmt_value = targetOf_compute(stmt);
        if(isFinal && num == boundariesCrossed)
            targetOf_ContinueStmt_values.put(_parameters, Boolean.valueOf(targetOf_ContinueStmt_value));
        targetOf_ContinueStmt_visited.remove(_parameters);
        return targetOf_ContinueStmt_value;
    }

    private boolean targetOf_compute(ContinueStmt stmt) {  return !stmt.hasLabel();  }

    protected java.util.Map targetOf_BreakStmt_visited;
    protected java.util.Map targetOf_BreakStmt_values;
    // Declared in BranchTarget.jrag at line 80
 @SuppressWarnings({"unchecked", "cast"})     public boolean targetOf(BreakStmt stmt) {
        Object _parameters = stmt;
if(targetOf_BreakStmt_visited == null) targetOf_BreakStmt_visited = new java.util.HashMap(4);
if(targetOf_BreakStmt_values == null) targetOf_BreakStmt_values = new java.util.HashMap(4);
        if(targetOf_BreakStmt_values.containsKey(_parameters))
            return ((Boolean)targetOf_BreakStmt_values.get(_parameters)).booleanValue();
        if(new Integer(boundariesCrossed).equals(targetOf_BreakStmt_visited.get(_parameters)))
            throw new RuntimeException("Circular definition of attr: targetOf in class: ");
        targetOf_BreakStmt_visited.put(_parameters, new Integer(boundariesCrossed));
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        boolean targetOf_BreakStmt_value = targetOf_compute(stmt);
        if(isFinal && num == boundariesCrossed)
            targetOf_BreakStmt_values.put(_parameters, Boolean.valueOf(targetOf_BreakStmt_value));
        targetOf_BreakStmt_visited.remove(_parameters);
        return targetOf_BreakStmt_value;
    }

    private boolean targetOf_compute(BreakStmt stmt) {  return !stmt.hasLabel();  }

    protected java.util.Map isDAafter_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 613
 @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) {
    if(!(!hasCondition() || getCondition().isDAafterFalse(v)))
      return false;
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDAafterReachedFinallyBlocks(v))
        return false;
    }
    return true;
  }

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

    private boolean isDAafterInitialization_compute(Variable v) {  return getNumInitStmt() == 0 ? isDAbefore(v) : getInitStmt(getNumInitStmt()-1).isDAafter(v);  }

    protected java.util.Map isDUafter_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 1100
 @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) {
    if(!isDUbeforeCondition(v)) // start a circular evaluation here
      return false;
    if(!(!hasCondition() || getCondition().isDUafterFalse(v))) {
      return false;
    }
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDUafterReachedFinallyBlocks(v))
        return false;
    }
    //if(!isDUafterUpdate(v))
    //  return false;
    return true;
  }

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

    private boolean isDUafterInit_compute(Variable v) {  return getNumInitStmt() == 0 ? isDUbefore(v) : getInitStmt(getNumInitStmt()-1).isDUafter(v);  }

    protected java.util.Map isDUbeforeCondition_Variable_visited;
    protected java.util.Set isDUbeforeCondition_Variable_computed = new java.util.HashSet(4);
    protected java.util.Set isDUbeforeCondition_Variable_initialized = new java.util.HashSet(4);
    protected java.util.Map isDUbeforeCondition_Variable_values = new java.util.HashMap(4);
 @SuppressWarnings({"unchecked", "cast"})     public boolean isDUbeforeCondition(Variable v) {
        Object _parameters = v;
if(isDUbeforeCondition_Variable_visited == null) isDUbeforeCondition_Variable_visited = new java.util.HashMap(4);
if(isDUbeforeCondition_Variable_values == null) isDUbeforeCondition_Variable_values = new java.util.HashMap(4);
        if(isDUbeforeCondition_Variable_computed.contains(_parameters))
            return ((Boolean)isDUbeforeCondition_Variable_values.get(_parameters)).booleanValue();
        if (!isDUbeforeCondition_Variable_initialized.contains(_parameters)) {
            isDUbeforeCondition_Variable_initialized.add(_parameters);
            isDUbeforeCondition_Variable_values.put(_parameters, Boolean.valueOf(true));
        }
        if (!IN_CIRCLE) {
            IN_CIRCLE = true;
            int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
            CIRCLE_INDEX = 1;
            boolean new_isDUbeforeCondition_Variable_value;
            do {
                isDUbeforeCondition_Variable_visited.put(_parameters, new Integer(CIRCLE_INDEX));
                CHANGE = false;
        if(getParent() == null) throw new RuntimeException("Trying to evaluate attribute in subtree not attached to main tree");                new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v);
                if (new_isDUbeforeCondition_Variable_value!=((Boolean)isDUbeforeCondition_Variable_values.get(_parameters)).booleanValue())
                    CHANGE = true;
                isDUbeforeCondition_Variable_values.put(_parameters, Boolean.valueOf(new_isDUbeforeCondition_Variable_value));
                CIRCLE_INDEX++;
if(CIRCLE_INDEX > 100) throw new java.lang.RuntimeException("Iteration limit 100 exceeded");
            } while (CHANGE);
            if(isFinal && num == boundariesCrossed)
{
            isDUbeforeCondition_Variable_computed.add(_parameters);
            LAST_CYCLE = true;
        if(getParent() == null) throw new RuntimeException("Trying to evaluate attribute in subtree not attached to main tree");            isDUbeforeCondition_compute(v);
            LAST_CYCLE = false;
            }
            else {
            RESET_CYCLE = true;
        if(getParent() == null) throw new RuntimeException("Trying to evaluate attribute in subtree not attached to main tree");            isDUbeforeCondition_compute(v);
            RESET_CYCLE = false;
            isDUbeforeCondition_Variable_computed.remove(_parameters);
            isDUbeforeCondition_Variable_initialized.remove(_parameters);
            }
            IN_CIRCLE = false; 
            return new_isDUbeforeCondition_Variable_value;
        }
        if(!new Integer(CIRCLE_INDEX).equals(isDUbeforeCondition_Variable_visited.get(_parameters))) {
            isDUbeforeCondition_Variable_visited.put(_parameters, new Integer(CIRCLE_INDEX));
            if (LAST_CYCLE) {
                isDUbeforeCondition_Variable_computed.add(_parameters);
        if(getParent() == null) throw new RuntimeException("Trying to evaluate attribute in subtree not attached to main tree");                return isDUbeforeCondition_compute(v);
            }
            if (RESET_CYCLE) {
                isDUbeforeCondition_Variable_computed.remove(_parameters);
                isDUbeforeCondition_Variable_initialized.remove(_parameters);
                return ((Boolean)isDUbeforeCondition_Variable_values.get(_parameters)).booleanValue();
            }
        if(getParent() == null) throw new RuntimeException("Trying to evaluate attribute in subtree not attached to main tree");            boolean new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v);
            if (new_isDUbeforeCondition_Variable_value!=((Boolean)isDUbeforeCondition_Variable_values.get(_parameters)).booleanValue())
                CHANGE = true;
            isDUbeforeCondition_Variable_values.put(_parameters, Boolean.valueOf(new_isDUbeforeCondition_Variable_value));
            return new_isDUbeforeCondition_Variable_value;
        }