001    /* This file was generated with JastAdd2 (http://jastadd.org) version R20130213 */
002    package AST;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.*;
007    import beaver.*;
008    import java.util.ArrayList;
009    import java.util.zip.*;
010    import java.io.*;
011    import java.io.FileNotFoundException;
012    import java.util.Collection;
013    /**
014     * @production ExprStmt : {@link Stmt} ::= <span class="component">{@link Expr}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:200
017     */
018    public class ExprStmt extends Stmt implements Cloneable {
019      /**
020       * @apilevel low-level
021       */
022      public void flushCache() {
023      }
024      /**
025       * @apilevel internal
026       */
027      public void flushCollectionCache() {
028      }
029      /**
030       * @apilevel internal
031       */
032      @SuppressWarnings({"unchecked", "cast"})
033      public ExprStmt clone() throws CloneNotSupportedException {
034        ExprStmt node = (ExprStmt)super.clone();
035        node.isDAafter_Variable_values = null;
036        node.isDUafter_Variable_values = null;
037        node.canCompleteNormally_computed = false;
038        node.in$Circle(false);
039        node.is$Final(false);
040        return node;
041      }
042    /**
043     * @apilevel internal
044     */
045      @SuppressWarnings({"unchecked", "cast"})
046    public ExprStmt copy() {
047      
048      try {
049        ExprStmt node = (ExprStmt) clone();
050        node.parent = null;
051        if(children != null)
052          node.children = (ASTNode[]) children.clone();
053        
054        return node;
055      } catch (CloneNotSupportedException e) {
056        throw new Error("Error: clone not supported for " + getClass().getName());
057      }
058      
059    }/**
060     * Create a deep copy of the AST subtree at this node.
061     * The copy is dangling, i.e. has no parent.
062     * @return dangling copy of the subtree at this node
063     * @apilevel low-level
064     */
065      @SuppressWarnings({"unchecked", "cast"})
066    public ExprStmt fullCopy() {
067      
068      ExprStmt tree = (ExprStmt) copy();
069      if (children != null) {
070        for (int i = 0; i < children.length; ++i) {
071          
072          ASTNode child = (ASTNode) children[i];
073          if(child != null) {
074            child = child.fullCopy();
075            tree.setChild(child, i);
076          }
077        }
078      }
079      return tree;
080      
081    }  /**
082       * @ast method 
083       * @aspect PrettyPrint
084       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:548
085       */
086      public void toString(StringBuffer s) {
087        s.append(indent());
088        getExpr().toString(s);
089        s.append(";");
090      }
091      /**
092       * @ast method 
093       * @aspect CreateBCode
094       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1204
095       */
096      public void createBCode(CodeGeneration gen) {
097        super.createBCode(gen);
098        getExpr().createBCode(gen);
099        if(needsPop())
100          getExpr().type().emitPop(gen);
101      }
102      /**
103       * @ast method 
104       * 
105       */
106      public ExprStmt() {
107        super();
108    
109    
110      }
111      /**
112       * Initializes the child array to the correct size.
113       * Initializes List and Opt nta children.
114       * @apilevel internal
115       * @ast method
116       * @ast method 
117       * 
118       */
119      public void init$Children() {
120        children = new ASTNode[1];
121      }
122      /**
123       * @ast method 
124       * 
125       */
126      public ExprStmt(Expr p0) {
127        setChild(p0, 0);
128      }
129      /**
130       * @apilevel low-level
131       * @ast method 
132       * 
133       */
134      protected int numChildren() {
135        return 1;
136      }
137      /**
138       * @apilevel internal
139       * @ast method 
140       * 
141       */
142      public boolean mayHaveRewrite() {
143        return false;
144      }
145      /**
146       * Replaces the Expr child.
147       * @param node The new node to replace the Expr child.
148       * @apilevel high-level
149       * @ast method 
150       * 
151       */
152      public void setExpr(Expr node) {
153        setChild(node, 0);
154      }
155      /**
156       * Retrieves the Expr child.
157       * @return The current node used as the Expr child.
158       * @apilevel high-level
159       * @ast method 
160       * 
161       */
162      public Expr getExpr() {
163        return (Expr)getChild(0);
164      }
165      /**
166       * Retrieves the Expr child.
167       * <p><em>This method does not invoke AST transformations.</em></p>
168       * @return The current node used as the Expr child.
169       * @apilevel low-level
170       * @ast method 
171       * 
172       */
173      public Expr getExprNoTransform() {
174        return (Expr)getChildNoTransform(0);
175      }
176      protected java.util.Map isDAafter_Variable_values;
177      /**
178       * @attribute syn
179       * @aspect DA
180       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:522
181       */
182      @SuppressWarnings({"unchecked", "cast"})
183      public boolean isDAafter(Variable v) {
184        Object _parameters = v;
185        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
186        if(isDAafter_Variable_values.containsKey(_parameters)) {
187          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
188        }
189          ASTNode$State state = state();
190      int num = state.boundariesCrossed;
191      boolean isFinal = this.is$Final();
192        boolean isDAafter_Variable_value = isDAafter_compute(v);
193      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
194            return isDAafter_Variable_value;
195      }
196      /**
197       * @apilevel internal
198       */
199      private boolean isDAafter_compute(Variable v) {  return getExpr().isDAafter(v);  }
200      protected java.util.Map isDUafter_Variable_values;
201      /**
202       * @attribute syn
203       * @aspect DU
204       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:991
205       */
206      @SuppressWarnings({"unchecked", "cast"})
207      public boolean isDUafter(Variable v) {
208        Object _parameters = v;
209        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
210        if(isDUafter_Variable_values.containsKey(_parameters)) {
211          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
212        }
213          ASTNode$State state = state();
214      int num = state.boundariesCrossed;
215      boolean isFinal = this.is$Final();
216        boolean isDUafter_Variable_value = isDUafter_compute(v);
217      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
218            return isDUafter_Variable_value;
219      }
220      /**
221       * @apilevel internal
222       */
223      private boolean isDUafter_compute(Variable v) {  return getExpr().isDUafter(v);  }
224      /**
225       * @apilevel internal
226       */
227      protected boolean canCompleteNormally_computed = false;
228      /**
229       * @apilevel internal
230       */
231      protected boolean canCompleteNormally_value;
232      /**
233       * @attribute syn
234       * @aspect UnreachableStatements
235       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:58
236       */
237      @SuppressWarnings({"unchecked", "cast"})
238      public boolean canCompleteNormally() {
239        if(canCompleteNormally_computed) {
240          return canCompleteNormally_value;
241        }
242          ASTNode$State state = state();
243      int num = state.boundariesCrossed;
244      boolean isFinal = this.is$Final();
245        canCompleteNormally_value = canCompleteNormally_compute();
246      if(isFinal && num == state().boundariesCrossed){ canCompleteNormally_computed = true; }
247            return canCompleteNormally_value;
248      }
249      /**
250       * @apilevel internal
251       */
252      private boolean canCompleteNormally_compute() {  return reachable();  }
253      /**
254       * @attribute syn
255       * @aspect CodeGeneration
256       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:15
257       */
258      public int sourceLineNumber() {
259        ASTNode$State state = state();
260        try {  return getExpr().findFirstSourceLineNumber();  }
261        finally {
262        }
263      }
264      /**
265       * @attribute syn
266       * @aspect CreateBCode
267       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:218
268       */
269      public boolean needsPop() {
270        ASTNode$State state = state();
271        try {  return getExpr().needsPop();  }
272        finally {
273        }
274      }
275      /**
276       * @attribute syn
277       * @aspect PreciseRethrow
278       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:55
279       */
280      public boolean modifiedInScope(Variable var) {
281        ASTNode$State state = state();
282        try {  return getExpr().modifiedInScope(var);  }
283        finally {
284        }
285      }
286      /**
287       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:523
288       * @apilevel internal
289       */
290      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
291        if(caller == getExprNoTransform()) {
292          return isDAbefore(v);
293        }
294        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
295        }
296      }
297      /**
298       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:992
299       * @apilevel internal
300       */
301      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
302        if(caller == getExprNoTransform()) {
303          return isDUbefore(v);
304        }
305        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
306        }
307      }
308      /**
309       * @apilevel internal
310       */
311      public ASTNode rewriteTo() {
312        return super.rewriteTo();
313      }
314    }