trystmt.java

JDK1.4编译器前端

        return (List<CatchClause>)getChildNoTransform(1);
    }

    // Declared in java.ast at line 2
    // Declared in java.ast line 222
    public void setFinallyOpt(Opt<Block> opt) {
        setChild(opt, 2);
    }

    // Declared in java.ast at line 6


    public boolean hasFinally() {
        return getFinallyOpt().getNumChild() != 0;
    }

    // Declared in java.ast at line 10


     @SuppressWarnings({"unchecked", "cast"})  public Block getFinally() {
        return (Block)getFinallyOpt().getChild(0);
    }

    // Declared in java.ast at line 14


    public void setFinally(Block node) {
        getFinallyOpt().setChild(node, 0);
    }

    // Declared in java.ast at line 17

     @SuppressWarnings({"unchecked", "cast"})  public Opt<Block> getFinallyOpt() {
        return (Opt<Block>)getChild(2);
    }

    // Declared in java.ast at line 21


     @SuppressWarnings({"unchecked", "cast"})  public Opt<Block> getFinallyOptNoTransform() {
        return (Opt<Block>)getChildNoTransform(2);
    }

    protected int branches_visited = -1;
    protected boolean branches_computed = false;
    protected Collection branches_value;
    // Declared in BranchTarget.jrag at line 116
 @SuppressWarnings({"unchecked", "cast"})     public Collection branches() {
        if(branches_computed)
            return branches_value;
        if(branches_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: branches in class: ");
        branches_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        branches_value = branches_compute();
        if(isFinal && num == boundariesCrossed)
            branches_computed = true;
        branches_visited = -1;
        return branches_value;
    }

    private Collection branches_compute() {
    HashSet set = new HashSet();
    getBlock().collectBranches(set);
    for(int i = 0; i < getNumCatchClause(); i++)
      getCatchClause(i).collectBranches(set);
    return set;
  }

    protected int branchesFromFinally_visited = -1;
    protected boolean branchesFromFinally_computed = false;
    protected Collection branchesFromFinally_value;
    // Declared in BranchTarget.jrag at line 124
 @SuppressWarnings({"unchecked", "cast"})     public Collection branchesFromFinally() {
        if(branchesFromFinally_computed)
            return branchesFromFinally_value;
        if(branchesFromFinally_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: branchesFromFinally in class: ");
        branchesFromFinally_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        branchesFromFinally_value = branchesFromFinally_compute();
        if(isFinal && num == boundariesCrossed)
            branchesFromFinally_computed = true;
        branchesFromFinally_visited = -1;
        return branchesFromFinally_value;
    }

    private Collection branchesFromFinally_compute() {
    HashSet set = new HashSet();
    if(hasFinally())
      getFinally().collectBranches(set);
    return set;
  }

    protected int targetBranches_visited = -1;
    protected boolean targetBranches_computed = false;
    protected Collection targetBranches_value;
    // Declared in BranchTarget.jrag at line 132
 @SuppressWarnings({"unchecked", "cast"})     public Collection targetBranches() {
        if(targetBranches_computed)
            return targetBranches_value;
        if(targetBranches_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: targetBranches in class: ");
        targetBranches_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        targetBranches_value = targetBranches_compute();
        if(isFinal && num == boundariesCrossed)
            targetBranches_computed = true;
        targetBranches_visited = -1;
        return targetBranches_value;
    }

    private Collection targetBranches_compute() {
    HashSet set = new HashSet();
    if(hasFinally() && !getFinally().canCompleteNormally())
      set.addAll(branches());
    return set;
  }

    protected int escapedBranches_visited = -1;
    protected boolean escapedBranches_computed = false;
    protected Collection escapedBranches_value;
    // Declared in BranchTarget.jrag at line 140
 @SuppressWarnings({"unchecked", "cast"})     public Collection escapedBranches() {
        if(escapedBranches_computed)
            return escapedBranches_value;
        if(escapedBranches_visited == boundariesCrossed)
            throw new RuntimeException("Circular definition of attr: escapedBranches in class: ");
        escapedBranches_visited = boundariesCrossed;
        int num = boundariesCrossed;
        boolean isFinal = this.is$Final();
        escapedBranches_value = escapedBranches_compute();
        if(isFinal && num == boundariesCrossed)
            escapedBranches_computed = true;
        escapedBranches_visited = -1;
        return escapedBranches_value;
    }

    private Collection escapedBranches_compute() {
    HashSet set = new HashSet();
    if(hasFinally())
      set.addAll(branchesFromFinally());
    if(!hasFinally() || getFinally().canCompleteNormally())
      set.addAll(branches());
    return set;
  }

    protected java.util.Map isDAafter_Variable_visited;
    // Declared in DefiniteAssignment.jrag at line 667
 @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) {
    // 16.2.15 4th bullet
    if(!hasFinally()) {
      if(!getBlock().isDAafter(v))
        return false;
      for(int i = 0; i < getNumCatchClause(); i++)
        if(!getCatchClause(i).getBlock().isDAafter(v))
          return false;
      return true;
    }
    else {
      // 16.2.15 5th bullet
      if(getFinally().isDAafter(v))
        return true;
      if(!getBlock().isDAafter(v))
        return false;
      for(int i = 0; i < getNumCatchClause(); i++)
        if(!getCatchClause(i).getBlock().isDAafter(v))
          return false;
      return true;
    }
  }

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

    private boolean isDUafterFinally_compute(Variable v) {  return getFinally().isDUafter(v);  }

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

    private boolean isDAafterFinally_compute(Variable v) {  return getFinally().isDAafter(v);  }

    protected java.util.Map isDUbefore_Variable_visited;
    protected java.util.Set isDUbefore_Variable_computed = new java.util.HashSet(4);
    protected java.util.Set isDUbefore_Variable_initialized = new java.util.HashSet(4);
    protected java.util.Map isDUbefore_Variable_values = new java.util.HashMap(4);
 @SuppressWarnings({"unchecked", "cast"})     public boolean isDUbefore(Variable v) {
        Object _parameters = v;
if(isDUbefore_Variable_visited == null) isDUbefore_Variable_visited = new java.util.HashMap(4);
if(isDUbefore_Variable_values == null) isDUbefore_Variable_values = new java.util.HashMap(4);
        if(isDUbefore_Variable_computed.contains(_parameters))
            return ((Boolean)isDUbefore_Variable_values.get(_parameters)).booleanValue();
        if (!isDUbefore_Variable_initialized.contains(_parameters)) {
            isDUbefore_Variable_initialized.add(_parameters);
            isDUbefore_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_isDUbefore_Variable_value;
            do {
                isDUbefore_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_isDUbefore_Variable_value = isDUbefore_compute(v);
                if (new_isDUbefore_Variable_value!=((Boolean)isDUbefore_Variable_values.get(_parameters)).booleanValue())
                    CHANGE = true;
                isDUbefore_Variable_values.put(_parameters, Boolean.valueOf(new_isDUbefore_Variable_value));
                CIRCLE_INDEX++;
if(CIRCLE_INDEX > 100) throw new java.lang.RuntimeException("Iteration limit 100 exceeded");
            } while (CHANGE);
            if(isFinal && num == boundariesCrossed)
{
            isDUbefore_Variable_computed.add(_parameters);
            LAST_CYCLE = true;
        if(getParent() == null) throw new RuntimeException("Trying to evaluate attribute in subtree not attached to main tree");            isDUbefore_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");            isDUbefore_compute(v);
            RESET_CYCLE = false;
            isDUbefore_Variable_computed.remove(_parameters);
            isDUbefore_Variable_initialized.remove(_parameters);
            }
            IN_CIRCLE = false; 
            return new_isDUbefore_Variable_value;
        }
        if(!new Integer(CIRCLE_INDEX).equals(isDUbefore_Variable_visited.get(_parameters))) {
            isDUbefore_Variable_visited.put(_parameters, new Integer(CIRCLE_INDEX));
            if (LAST_CYCLE) {
                isDUbefore_Variable_computed.add(_parameters);