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:192
027     * @production BranchTargetStmt : {@link Stmt};
028    
029     */
030    public abstract class BranchTargetStmt extends Stmt implements Cloneable {
031      /**
032       * @aspect BranchTarget
033       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:108
034       */
035      public void collectBranches(Collection<Stmt> c) {
036        c.addAll(escapedBranches());
037      }
038      /**
039       * @declaredat ASTNode:1
040       */
041      public BranchTargetStmt() {
042        super();
043      }
044      /**
045       * Initializes the child array to the correct size.
046       * Initializes List and Opt nta children.
047       * @apilevel internal
048       * @ast method
049       * @declaredat ASTNode:10
050       */
051      public void init$Children() {
052      }
053      /**
054       * @apilevel low-level
055       * @declaredat ASTNode:15
056       */
057      protected int numChildren() {
058        return 0;
059      }
060      /**
061       * @apilevel internal
062       * @declaredat ASTNode:21
063       */
064      public boolean mayHaveRewrite() {
065        return false;
066      }
067      /**
068       * @apilevel internal
069       * @declaredat ASTNode:27
070       */
071      public void flushAttrCache() {
072        super.flushAttrCache();
073        targetBranches_reset();
074        escapedBranches_reset();
075        branches_reset();
076        targetContinues_reset();
077        targetBreaks_reset();
078        reachableBreak_reset();
079        reachableContinue_reset();
080      }
081      /**
082       * @apilevel internal
083       * @declaredat ASTNode:40
084       */
085      public void flushCollectionCache() {
086        super.flushCollectionCache();
087      }
088      /**
089       * @apilevel internal
090       * @declaredat ASTNode:46
091       */
092      public void flushRewriteCache() {
093        super.flushRewriteCache();
094      }
095      /**
096       * @apilevel internal
097       * @declaredat ASTNode:52
098       */
099      public BranchTargetStmt clone() throws CloneNotSupportedException {
100        BranchTargetStmt node = (BranchTargetStmt) super.clone();
101        return node;
102      }
103      /**
104       * Create a deep copy of the AST subtree at this node.
105       * The copy is dangling, i.e. has no parent.
106       * @return dangling copy of the subtree at this node
107       * @apilevel low-level
108       * @deprecated Please use treeCopy or treeCopyNoTransform instead
109       * @declaredat ASTNode:63
110       */
111      @Deprecated
112      public abstract BranchTargetStmt fullCopy();
113      /**
114       * Create a deep copy of the AST subtree at this node.
115       * The copy is dangling, i.e. has no parent.
116       * @return dangling copy of the subtree at this node
117       * @apilevel low-level
118       * @declaredat ASTNode:71
119       */
120      public abstract BranchTargetStmt treeCopyNoTransform();
121      /**
122       * Create a deep copy of the AST subtree at this node.
123       * The subtree of this node is traversed to trigger rewrites before copy.
124       * The copy is dangling, i.e. has no parent.
125       * @return dangling copy of the subtree at this node
126       * @apilevel low-level
127       * @declaredat ASTNode:79
128       */
129      public abstract BranchTargetStmt treeCopy();
130      /**
131       * @apilevel internal
132       */
133      protected boolean targetBranches_computed = false;
134      /**
135       * @apilevel internal
136       */
137      protected Collection<Stmt> targetBranches_value;
138      /**
139       * @apilevel internal
140       */
141      private void targetBranches_reset() {
142        targetBranches_computed = false;
143        targetBranches_value = null;
144      }
145      /**
146       * @attribute syn
147       * @aspect BranchTarget
148       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:86
149       */
150      @ASTNodeAnnotation.Attribute
151      public Collection<Stmt> targetBranches() {
152        ASTNode$State state = state();
153        if (targetBranches_computed) {
154          return targetBranches_value;
155        }
156        boolean intermediate = state.INTERMEDIATE_VALUE;
157        state.INTERMEDIATE_VALUE = false;
158        int num = state.boundariesCrossed;
159        boolean isFinal = this.is$Final();
160        targetBranches_value = targetBranches_compute();
161        if (isFinal && num == state().boundariesCrossed) {
162          targetBranches_computed = true;
163        } else {
164        }
165        state.INTERMEDIATE_VALUE |= intermediate;
166    
167        return targetBranches_value;
168      }
169      /**
170       * @apilevel internal
171       */
172      private Collection<Stmt> targetBranches_compute() {
173          Collection<Stmt> set = new HashSet<Stmt>();
174          for (Stmt branch : branches()) {
175            if (potentialTargetOf(branch)) {
176              set.add(branch);
177            }
178          }
179          return set;
180        }
181      /**
182       * @apilevel internal
183       */
184      protected boolean escapedBranches_computed = false;
185      /**
186       * @apilevel internal
187       */
188      protected Collection<Stmt> escapedBranches_value;
189      /**
190       * @apilevel internal
191       */
192      private void escapedBranches_reset() {
193        escapedBranches_computed = false;
194        escapedBranches_value = null;
195      }
196      /**
197       * @attribute syn
198       * @aspect BranchTarget
199       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:87
200       */
201      @ASTNodeAnnotation.Attribute
202      public Collection<Stmt> escapedBranches() {
203        ASTNode$State state = state();
204        if (escapedBranches_computed) {
205          return escapedBranches_value;
206        }
207        boolean intermediate = state.INTERMEDIATE_VALUE;
208        state.INTERMEDIATE_VALUE = false;
209        int num = state.boundariesCrossed;
210        boolean isFinal = this.is$Final();
211        escapedBranches_value = escapedBranches_compute();
212        if (isFinal && num == state().boundariesCrossed) {
213          escapedBranches_computed = true;
214        } else {
215        }
216        state.INTERMEDIATE_VALUE |= intermediate;
217    
218        return escapedBranches_value;
219      }
220      /**
221       * @apilevel internal
222       */
223      private Collection<Stmt> escapedBranches_compute() {
224          Collection<Stmt> set = new HashSet<Stmt>();
225          for (Stmt branch : branches()) {
226            if (!potentialTargetOf(branch)) {
227              set.add(branch);
228            } else if (branch instanceof ReturnStmt) {
229              set.add(branch);
230            }
231          }
232          return set;
233        }
234      /**
235       * @apilevel internal
236       */
237      protected boolean branches_computed = false;
238      /**
239       * @apilevel internal
240       */
241      protected Collection<Stmt> branches_value;
242      /**
243       * @apilevel internal
244       */
245      private void branches_reset() {
246        branches_computed = false;
247        branches_value = null;
248      }
249      /**
250       * @attribute syn
251       * @aspect BranchTarget
252       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:88
253       */
254      @ASTNodeAnnotation.Attribute
255      public Collection<Stmt> branches() {
256        ASTNode$State state = state();
257        if (branches_computed) {
258          return branches_value;
259        }
260        boolean intermediate = state.INTERMEDIATE_VALUE;
261        state.INTERMEDIATE_VALUE = false;
262        int num = state.boundariesCrossed;
263        boolean isFinal = this.is$Final();
264        branches_value = branches_compute();
265        if (isFinal && num == state().boundariesCrossed) {
266          branches_computed = true;
267        } else {
268        }
269        state.INTERMEDIATE_VALUE |= intermediate;
270    
271        return branches_value;
272      }
273      /**
274       * @apilevel internal
275       */
276      private Collection<Stmt> branches_compute() {
277          Collection<Stmt> set = new HashSet<Stmt>();
278          super.collectBranches(set);
279          return set;
280        }
281      /**
282       * @return <code>true</code> if this statement is a potential
283       * branch target of the given branch statement.
284       * @attribute syn
285       * @aspect BranchTarget
286       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:217
287       */
288      @ASTNodeAnnotation.Attribute
289      public boolean potentialTargetOf(Stmt branch) {
290        boolean potentialTargetOf_Stmt_value = false;
291    
292        return potentialTargetOf_Stmt_value;
293      }
294      /**
295       * @apilevel internal
296       */
297      protected boolean targetContinues_computed = false;
298      /**
299       * @apilevel internal
300       */
301      protected Collection<Stmt> targetContinues_value;
302      /**
303       * @apilevel internal
304       */
305      private void targetContinues_reset() {
306        targetContinues_computed = false;
307        targetContinues_value = null;
308      }
309      /**
310       * @attribute syn
311       * @aspect BranchTarget
312       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:84
313       */
314      @ASTNodeAnnotation.Attribute
315      public Collection<Stmt> targetContinues() {
316        ASTNode$State state = state();
317        if (targetContinues_computed) {
318          return targetContinues_value;
319        }
320        boolean intermediate = state.INTERMEDIATE_VALUE;
321        state.INTERMEDIATE_VALUE = false;
322        int num = state.boundariesCrossed;
323        boolean isFinal = this.is$Final();
324        targetContinues_value = targetContinues_compute();
325        if (isFinal && num == state().boundariesCrossed) {
326          targetContinues_computed = true;
327        } else {
328        }
329        state.INTERMEDIATE_VALUE |= intermediate;
330    
331        return targetContinues_value;
332      }
333      /**
334       * @apilevel internal
335       */
336      private Collection<Stmt> targetContinues_compute() {
337          HashSet<Stmt> set = new HashSet<Stmt>();
338          for (Stmt branch : targetBranches()) {
339            if (branch instanceof ContinueStmt) {
340              set.add(branch);
341            }
342          }
343          if (getParent() instanceof LabeledStmt) {
344            for (Stmt branch : ((LabeledStmt) getParent()).targetBranches()) {
345              if (branch instanceof ContinueStmt) {
346                set.add(branch);
347              }
348            }
349          }
350          return set;
351        }
352      /**
353       * @apilevel internal
354       */
355      protected boolean targetBreaks_computed = false;
356      /**
357       * @apilevel internal
358       */
359      protected Collection<Stmt> targetBreaks_value;
360      /**
361       * @apilevel internal
362       */
363      private void targetBreaks_reset() {
364        targetBreaks_computed = false;
365        targetBreaks_value = null;
366      }
367      /**
368       * @attribute syn
369       * @aspect BranchTarget
370       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:85
371       */
372      @ASTNodeAnnotation.Attribute
373      public Collection<Stmt> targetBreaks() {
374        ASTNode$State state = state();
375        if (targetBreaks_computed) {
376          return targetBreaks_value;
377        }
378        boolean intermediate = state.INTERMEDIATE_VALUE;
379        state.INTERMEDIATE_VALUE = false;
380        int num = state.boundariesCrossed;
381        boolean isFinal = this.is$Final();
382        targetBreaks_value = targetBreaks_compute();
383        if (isFinal && num == state().boundariesCrossed) {
384          targetBreaks_computed = true;
385        } else {
386        }
387        state.INTERMEDIATE_VALUE |= intermediate;
388    
389        return targetBreaks_value;
390      }
391      /**
392       * @apilevel internal
393       */
394      private Collection<Stmt> targetBreaks_compute() {
395          HashSet<Stmt> set = new HashSet<Stmt>();
396          for (Stmt branch : targetBranches()) {
397            if (branch instanceof BreakStmt) {
398              set.add(branch);
399            }
400          }
401          return set;
402        }
403      /**
404       * @apilevel internal
405       */
406      protected boolean reachableBreak_computed = false;
407      /**
408       * @apilevel internal
409       */
410      protected boolean reachableBreak_value;
411      /**
412       * @apilevel internal
413       */
414      private void reachableBreak_reset() {
415        reachableBreak_computed = false;
416      }
417      /**
418       * @attribute syn
419       * @aspect UnreachableStatements
420       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:86
421       */
422      @ASTNodeAnnotation.Attribute
423      public boolean reachableBreak() {
424        ASTNode$State state = state();
425        if (reachableBreak_computed) {
426          return reachableBreak_value;
427        }
428        boolean intermediate = state.INTERMEDIATE_VALUE;
429        state.INTERMEDIATE_VALUE = false;
430        int num = state.boundariesCrossed;
431        boolean isFinal = this.is$Final();
432        reachableBreak_value = reachableBreak_compute();
433        if (isFinal && num == state().boundariesCrossed) {
434          reachableBreak_computed = true;
435        } else {
436        }
437        state.INTERMEDIATE_VALUE |= intermediate;
438    
439        return reachableBreak_value;
440      }
441      /**
442       * @apilevel internal
443       */
444      private boolean reachableBreak_compute() {
445          for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
446            BreakStmt stmt = (BreakStmt) iter.next();
447            if (stmt.reachable()) {
448              return true;
449            }
450          }
451          return false;
452        }
453      /**
454       * @apilevel internal
455       */
456      protected boolean reachableContinue_computed = false;
457      /**
458       * @apilevel internal
459       */
460      protected boolean reachableContinue_value;
461      /**
462       * @apilevel internal
463       */
464      private void reachableContinue_reset() {
465        reachableContinue_computed = false;
466      }
467      /**
468       * @attribute syn
469       * @aspect UnreachableStatements
470       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:142
471       */
472      @ASTNodeAnnotation.Attribute
473      public boolean reachableContinue() {
474        ASTNode$State state = state();
475        if (reachableContinue_computed) {
476          return reachableContinue_value;
477        }
478        boolean intermediate = state.INTERMEDIATE_VALUE;
479        state.INTERMEDIATE_VALUE = false;
480        int num = state.boundariesCrossed;
481        boolean isFinal = this.is$Final();
482        reachableContinue_value = reachableContinue_compute();
483        if (isFinal && num == state().boundariesCrossed) {
484          reachableContinue_computed = true;
485        } else {
486        }
487        state.INTERMEDIATE_VALUE |= intermediate;
488    
489        return reachableContinue_value;
490      }
491      /**
492       * @apilevel internal
493       */
494      private boolean reachableContinue_compute() {
495          for (Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
496            Stmt stmt = (Stmt) iter.next();
497            if (stmt.reachable()) {
498              return true;
499            }
500          }
501          return false;
502        }
503      /**
504       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:262
505       * @apilevel internal
506       */
507      public FinallyHost Define_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) {
508        int childIndex = this.getIndexOfChild(caller);
509        return potentialTargetOf(branch) ? null : enclosingFinally(branch);
510      }
511      protected boolean canDefine_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) {
512        return true;
513      }
514      /**
515       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1836
516       * @apilevel internal
517       */
518      public boolean Define_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) {
519        int childIndex = this.getIndexOfChild(caller);
520        {
521            if (potentialTargetOf(branch)) {
522              return false;
523            } else {
524              return leavesMonitor(branch, monitor);
525            }
526          }
527      }
528      protected boolean canDefine_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) {
529        return true;
530      }
531      /**
532       * @apilevel internal
533       */
534      public ASTNode rewriteTo() {
535        return super.rewriteTo();
536      }
537    }