001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * @ast node
026     * @declaredat /home/jesper/git/extendj/java4/grammar/Java.ast:196
027     * @production ExprStmt : {@link Stmt} ::= <span class="component">{@link Expr}</span>;
028    
029     */
030    public class ExprStmt extends Stmt implements Cloneable {
031      /**
032       * @aspect Java4PrettyPrint
033       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:151
034       */
035      public void prettyPrint(PrettyPrinter out) {
036        out.print(getExpr());
037        out.print(";");
038      }
039      /**
040       * @aspect CreateBCode
041       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1389
042       */
043      public void createBCode(CodeGeneration gen) {
044        super.createBCode(gen);
045        getExpr().createBCode(gen);
046        if (needsPop()) {
047          getExpr().type().emitPop(gen);
048        }
049      }
050      /**
051       * @declaredat ASTNode:1
052       */
053      public ExprStmt() {
054        super();
055      }
056      /**
057       * Initializes the child array to the correct size.
058       * Initializes List and Opt nta children.
059       * @apilevel internal
060       * @ast method
061       * @declaredat ASTNode:10
062       */
063      public void init$Children() {
064        children = new ASTNode[1];
065      }
066      /**
067       * @declaredat ASTNode:13
068       */
069      public ExprStmt(Expr p0) {
070        setChild(p0, 0);
071      }
072      /**
073       * @apilevel low-level
074       * @declaredat ASTNode:19
075       */
076      protected int numChildren() {
077        return 1;
078      }
079      /**
080       * @apilevel internal
081       * @declaredat ASTNode:25
082       */
083      public boolean mayHaveRewrite() {
084        return false;
085      }
086      /**
087       * @apilevel internal
088       * @declaredat ASTNode:31
089       */
090      public void flushAttrCache() {
091        super.flushAttrCache();
092        isDAafter_Variable_reset();
093        isDUafter_Variable_reset();
094        canCompleteNormally_reset();
095      }
096      /**
097       * @apilevel internal
098       * @declaredat ASTNode:40
099       */
100      public void flushCollectionCache() {
101        super.flushCollectionCache();
102      }
103      /**
104       * @apilevel internal
105       * @declaredat ASTNode:46
106       */
107      public void flushRewriteCache() {
108        super.flushRewriteCache();
109      }
110      /**
111       * @apilevel internal
112       * @declaredat ASTNode:52
113       */
114      public ExprStmt clone() throws CloneNotSupportedException {
115        ExprStmt node = (ExprStmt) super.clone();
116        return node;
117      }
118      /**
119       * @apilevel internal
120       * @declaredat ASTNode:59
121       */
122      public ExprStmt copy() {
123        try {
124          ExprStmt node = (ExprStmt) clone();
125          node.parent = null;
126          if (children != null) {
127            node.children = (ASTNode[]) children.clone();
128          }
129          return node;
130        } catch (CloneNotSupportedException e) {
131          throw new Error("Error: clone not supported for " + getClass().getName());
132        }
133      }
134      /**
135       * Create a deep copy of the AST subtree at this node.
136       * The copy is dangling, i.e. has no parent.
137       * @return dangling copy of the subtree at this node
138       * @apilevel low-level
139       * @deprecated Please use treeCopy or treeCopyNoTransform instead
140       * @declaredat ASTNode:78
141       */
142      @Deprecated
143      public ExprStmt fullCopy() {
144        return treeCopyNoTransform();
145      }
146      /**
147       * Create a deep copy of the AST subtree at this node.
148       * The copy is dangling, i.e. has no parent.
149       * @return dangling copy of the subtree at this node
150       * @apilevel low-level
151       * @declaredat ASTNode:88
152       */
153      public ExprStmt treeCopyNoTransform() {
154        ExprStmt tree = (ExprStmt) copy();
155        if (children != null) {
156          for (int i = 0; i < children.length; ++i) {
157            ASTNode child = (ASTNode) children[i];
158            if (child != null) {
159              child = child.treeCopyNoTransform();
160              tree.setChild(child, i);
161            }
162          }
163        }
164        return tree;
165      }
166      /**
167       * Create a deep copy of the AST subtree at this node.
168       * The subtree of this node is traversed to trigger rewrites before copy.
169       * The copy is dangling, i.e. has no parent.
170       * @return dangling copy of the subtree at this node
171       * @apilevel low-level
172       * @declaredat ASTNode:108
173       */
174      public ExprStmt treeCopy() {
175        doFullTraversal();
176        return treeCopyNoTransform();
177      }
178      /**
179       * @apilevel internal
180       * @declaredat ASTNode:115
181       */
182      protected boolean is$Equal(ASTNode node) {
183        return super.is$Equal(node);    
184      }
185      /**
186       * Replaces the Expr child.
187       * @param node The new node to replace the Expr child.
188       * @apilevel high-level
189       */
190      public void setExpr(Expr node) {
191        setChild(node, 0);
192      }
193      /**
194       * Retrieves the Expr child.
195       * @return The current node used as the Expr child.
196       * @apilevel high-level
197       */
198      @ASTNodeAnnotation.Child(name="Expr")
199      public Expr getExpr() {
200        return (Expr) getChild(0);
201      }
202      /**
203       * Retrieves the Expr child.
204       * <p><em>This method does not invoke AST transformations.</em></p>
205       * @return The current node used as the Expr child.
206       * @apilevel low-level
207       */
208      public Expr getExprNoTransform() {
209        return (Expr) getChildNoTransform(0);
210      }
211      /**
212       * @apilevel internal
213       */
214      protected java.util.Map isDAafter_Variable_values;
215      /**
216       * @apilevel internal
217       */
218      private void isDAafter_Variable_reset() {
219        isDAafter_Variable_values = null;
220      }
221      /**
222       * @attribute syn
223       * @aspect DA
224       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257
225       */
226      @ASTNodeAnnotation.Attribute
227      public boolean isDAafter(Variable v) {
228        Object _parameters = v;
229        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
230        ASTNode$State state = state();
231        if (isDAafter_Variable_values.containsKey(_parameters)) {
232          return (Boolean) isDAafter_Variable_values.get(_parameters);
233        }
234        boolean intermediate = state.INTERMEDIATE_VALUE;
235        state.INTERMEDIATE_VALUE = false;
236        int num = state.boundariesCrossed;
237        boolean isFinal = this.is$Final();
238        boolean isDAafter_Variable_value = getExpr().isDAafter(v);
239        if (isFinal && num == state().boundariesCrossed) {
240          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
241        } else {
242        }
243        state.INTERMEDIATE_VALUE |= intermediate;
244    
245        return isDAafter_Variable_value;
246      }
247      /**
248       * @apilevel internal
249       */
250      protected java.util.Map isDUafter_Variable_values;
251      /**
252       * @apilevel internal
253       */
254      private void isDUafter_Variable_reset() {
255        isDUafter_Variable_values = null;
256      }
257      /**
258       * @attribute syn
259       * @aspect DU
260       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781
261       */
262      @ASTNodeAnnotation.Attribute
263      public boolean isDUafter(Variable v) {
264        Object _parameters = v;
265        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
266        ASTNode$State state = state();
267        if (isDUafter_Variable_values.containsKey(_parameters)) {
268          return (Boolean) isDUafter_Variable_values.get(_parameters);
269        }
270        boolean intermediate = state.INTERMEDIATE_VALUE;
271        state.INTERMEDIATE_VALUE = false;
272        int num = state.boundariesCrossed;
273        boolean isFinal = this.is$Final();
274        boolean isDUafter_Variable_value = getExpr().isDUafter(v);
275        if (isFinal && num == state().boundariesCrossed) {
276          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
277        } else {
278        }
279        state.INTERMEDIATE_VALUE |= intermediate;
280    
281        return isDUafter_Variable_value;
282      }
283      /**
284       * @apilevel internal
285       */
286      protected boolean canCompleteNormally_computed = false;
287      /**
288       * @apilevel internal
289       */
290      protected boolean canCompleteNormally_value;
291      /**
292       * @apilevel internal
293       */
294      private void canCompleteNormally_reset() {
295        canCompleteNormally_computed = false;
296      }
297      /**
298       * @attribute syn
299       * @aspect UnreachableStatements
300       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53
301       */
302      @ASTNodeAnnotation.Attribute
303      public boolean canCompleteNormally() {
304        ASTNode$State state = state();
305        if (canCompleteNormally_computed) {
306          return canCompleteNormally_value;
307        }
308        boolean intermediate = state.INTERMEDIATE_VALUE;
309        state.INTERMEDIATE_VALUE = false;
310        int num = state.boundariesCrossed;
311        boolean isFinal = this.is$Final();
312        canCompleteNormally_value = reachable();
313        if (isFinal && num == state().boundariesCrossed) {
314          canCompleteNormally_computed = true;
315        } else {
316        }
317        state.INTERMEDIATE_VALUE |= intermediate;
318    
319        return canCompleteNormally_value;
320      }
321      /**
322       * @attribute syn
323       * @aspect CodeGeneration
324       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:37
325       */
326      @ASTNodeAnnotation.Attribute
327      public int sourceLineNumber() {
328        int sourceLineNumber_value = getExpr().findFirstSourceLineNumber();
329    
330        return sourceLineNumber_value;
331      }
332      /**
333       * @attribute syn
334       * @aspect CreateBCode
335       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:250
336       */
337      @ASTNodeAnnotation.Attribute
338      public boolean needsPop() {
339        boolean needsPop_value = getExpr().needsPop();
340    
341        return needsPop_value;
342      }
343      /**
344       * @attribute syn
345       * @aspect PreciseRethrow
346       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84
347       */
348      @ASTNodeAnnotation.Attribute
349      public boolean modifiedInScope(Variable var) {
350        boolean modifiedInScope_Variable_value = getExpr().modifiedInScope(var);
351    
352        return modifiedInScope_Variable_value;
353      }
354      /**
355       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
356       * @apilevel internal
357       */
358      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
359        if (caller == getExprNoTransform()) {
360          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:588
361          return isDAbefore(v);
362        }
363        else {
364          return getParent().Define_isDAbefore(this, caller, v);
365        }
366      }
367      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
368        return true;
369      }
370      /**
371       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
372       * @apilevel internal
373       */
374      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
375        if (caller == getExprNoTransform()) {
376          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1149
377          return isDUbefore(v);
378        }
379        else {
380          return getParent().Define_isDUbefore(this, caller, v);
381        }
382      }
383      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
384        return true;
385      }
386      /**
387       * @apilevel internal
388       */
389      public ASTNode rewriteTo() {
390        return super.rewriteTo();
391      }
392    }