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 BreakStmt : {@link Stmt} ::= <span class="component">&lt;Label:String&gt;</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:212
017     */
018    public class BreakStmt 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 BreakStmt clone() throws CloneNotSupportedException {
034        BreakStmt node = (BreakStmt)super.clone();
035        node.targetStmt_computed = false;
036        node.targetStmt_value = null;
037        node.finallyList_computed = false;
038        node.finallyList_value = null;
039        node.isDAafter_Variable_values = null;
040        node.isDUafterReachedFinallyBlocks_Variable_values = null;
041        node.isDAafterReachedFinallyBlocks_Variable_values = null;
042        node.isDUafter_Variable_values = null;
043        node.canCompleteNormally_computed = false;
044        node.lookupLabel_String_values = null;
045        node.in$Circle(false);
046        node.is$Final(false);
047        return node;
048      }
049    /**
050     * @apilevel internal
051     */
052      @SuppressWarnings({"unchecked", "cast"})
053    public BreakStmt copy() {
054      
055      try {
056        BreakStmt node = (BreakStmt) clone();
057        node.parent = null;
058        if(children != null)
059          node.children = (ASTNode[]) children.clone();
060        
061        return node;
062      } catch (CloneNotSupportedException e) {
063        throw new Error("Error: clone not supported for " + getClass().getName());
064      }
065      
066    }/**
067     * Create a deep copy of the AST subtree at this node.
068     * The copy is dangling, i.e. has no parent.
069     * @return dangling copy of the subtree at this node
070     * @apilevel low-level
071     */
072      @SuppressWarnings({"unchecked", "cast"})
073    public BreakStmt fullCopy() {
074      
075      BreakStmt tree = (BreakStmt) copy();
076      if (children != null) {
077        for (int i = 0; i < children.length; ++i) {
078          
079          ASTNode child = (ASTNode) children[i];
080          if(child != null) {
081            child = child.fullCopy();
082            tree.setChild(child, i);
083          }
084        }
085      }
086      return tree;
087      
088    }  /**
089       * @ast method 
090       * @aspect BranchTarget
091       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:51
092       */
093      public void collectBranches(Collection c) {
094        c.add(this);
095      }
096      /**
097       * @ast method 
098       * @aspect NameCheck
099       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:379
100       */
101      public void nameCheck() {
102        if(!hasLabel() && !insideLoop() && !insideSwitch())
103          error("break outside switch or loop");
104        else if(hasLabel()) {
105          LabeledStmt label = lookupLabel(getLabel());
106          if(label == null)
107            error("labeled break must have visible matching label");
108        }
109      }
110      /**
111       * @ast method 
112       * @aspect PrettyPrint
113       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:667
114       */
115      public void toString(StringBuffer s) {
116        s.append(indent());
117        s.append("break ");
118        if(hasLabel())
119          s.append(getLabel());
120        s.append(";");
121      }
122      /**
123       * @ast method 
124       * @aspect CreateBCode
125       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1408
126       */
127      public void createBCode(CodeGeneration gen) {
128        super.createBCode(gen);
129        for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
130          FinallyHost stmt = (FinallyHost)iter.next();
131          gen.emitJsr(stmt.label_finally_block());
132        }
133        gen.emitGoto(targetStmt().break_label());
134      }
135      /**
136       * @ast method 
137       * 
138       */
139      public BreakStmt() {
140        super();
141    
142    
143      }
144      /**
145       * Initializes the child array to the correct size.
146       * Initializes List and Opt nta children.
147       * @apilevel internal
148       * @ast method
149       * @ast method 
150       * 
151       */
152      public void init$Children() {
153      }
154      /**
155       * @ast method 
156       * 
157       */
158      public BreakStmt(String p0) {
159        setLabel(p0);
160      }
161      /**
162       * @ast method 
163       * 
164       */
165      public BreakStmt(beaver.Symbol p0) {
166        setLabel(p0);
167      }
168      /**
169       * @apilevel low-level
170       * @ast method 
171       * 
172       */
173      protected int numChildren() {
174        return 0;
175      }
176      /**
177       * @apilevel internal
178       * @ast method 
179       * 
180       */
181      public boolean mayHaveRewrite() {
182        return false;
183      }
184      /**
185       * Replaces the lexeme Label.
186       * @param value The new value for the lexeme Label.
187       * @apilevel high-level
188       * @ast method 
189       * 
190       */
191      public void setLabel(String value) {
192        tokenString_Label = value;
193      }
194      /**
195       * @apilevel internal
196       * @ast method 
197       * 
198       */
199      
200      /**
201       * @apilevel internal
202       */
203      protected String tokenString_Label;
204      /**
205       * @ast method 
206       * 
207       */
208      
209      public int Labelstart;
210      /**
211       * @ast method 
212       * 
213       */
214      
215      public int Labelend;
216      /**
217       * JastAdd-internal setter for lexeme Label using the Beaver parser.
218       * @apilevel internal
219       * @ast method 
220       * 
221       */
222      public void setLabel(beaver.Symbol symbol) {
223        if(symbol.value != null && !(symbol.value instanceof String))
224          throw new UnsupportedOperationException("setLabel is only valid for String lexemes");
225        tokenString_Label = (String)symbol.value;
226        Labelstart = symbol.getStart();
227        Labelend = symbol.getEnd();
228      }
229      /**
230       * Retrieves the value for the lexeme Label.
231       * @return The value for the lexeme Label.
232       * @apilevel high-level
233       * @ast method 
234       * 
235       */
236      public String getLabel() {
237        return tokenString_Label != null ? tokenString_Label : "";
238      }
239      /**
240       * @attribute syn
241       * @aspect BranchTarget
242       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:65
243       */
244      public boolean hasLabel() {
245        ASTNode$State state = state();
246        try {  return !getLabel().equals("");  }
247        finally {
248        }
249      }
250      /**
251       * @apilevel internal
252       */
253      protected boolean targetStmt_computed = false;
254      /**
255       * @apilevel internal
256       */
257      protected Stmt targetStmt_value;
258      /**
259       * @attribute syn
260       * @aspect BranchTarget
261       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:148
262       */
263      @SuppressWarnings({"unchecked", "cast"})
264      public Stmt targetStmt() {
265        if(targetStmt_computed) {
266          return targetStmt_value;
267        }
268          ASTNode$State state = state();
269      int num = state.boundariesCrossed;
270      boolean isFinal = this.is$Final();
271        targetStmt_value = targetStmt_compute();
272      if(isFinal && num == state().boundariesCrossed){ targetStmt_computed = true; }
273            return targetStmt_value;
274      }
275      /**
276       * @apilevel internal
277       */
278      private Stmt targetStmt_compute() {  return branchTarget(this);  }
279      /**
280       * @apilevel internal
281       */
282      protected boolean finallyList_computed = false;
283      /**
284       * @apilevel internal
285       */
286      protected ArrayList finallyList_value;
287      /**
288       * @attribute syn
289       * @aspect BranchTarget
290       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:175
291       */
292      @SuppressWarnings({"unchecked", "cast"})
293      public ArrayList finallyList() {
294        if(finallyList_computed) {
295          return finallyList_value;
296        }
297          ASTNode$State state = state();
298      int num = state.boundariesCrossed;
299      boolean isFinal = this.is$Final();
300        finallyList_value = finallyList_compute();
301      if(isFinal && num == state().boundariesCrossed){ finallyList_computed = true; }
302            return finallyList_value;
303      }
304      /**
305       * @apilevel internal
306       */
307      private ArrayList finallyList_compute() {
308        ArrayList list = new ArrayList();
309        collectFinally(this, list);
310        return list;
311      }
312      protected java.util.Map isDAafter_Variable_values;
313      /**
314       * @attribute syn
315       * @aspect DA
316       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:647
317       */
318      @SuppressWarnings({"unchecked", "cast"})
319      public boolean isDAafter(Variable v) {
320        Object _parameters = v;
321        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
322        if(isDAafter_Variable_values.containsKey(_parameters)) {
323          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
324        }
325          ASTNode$State state = state();
326      int num = state.boundariesCrossed;
327      boolean isFinal = this.is$Final();
328        boolean isDAafter_Variable_value = isDAafter_compute(v);
329      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
330            return isDAafter_Variable_value;
331      }
332      /**
333       * @apilevel internal
334       */
335      private boolean isDAafter_compute(Variable v) {  return true;  }
336      protected java.util.Map isDUafterReachedFinallyBlocks_Variable_values;
337      /**
338       * @attribute syn
339       * @aspect DU
340       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:921
341       */
342      @SuppressWarnings({"unchecked", "cast"})
343      public boolean isDUafterReachedFinallyBlocks(Variable v) {
344        Object _parameters = v;
345        if(isDUafterReachedFinallyBlocks_Variable_values == null) isDUafterReachedFinallyBlocks_Variable_values = new java.util.HashMap(4);
346        if(isDUafterReachedFinallyBlocks_Variable_values.containsKey(_parameters)) {
347          return ((Boolean)isDUafterReachedFinallyBlocks_Variable_values.get(_parameters)).booleanValue();
348        }
349          ASTNode$State state = state();
350      int num = state.boundariesCrossed;
351      boolean isFinal = this.is$Final();
352        boolean isDUafterReachedFinallyBlocks_Variable_value = isDUafterReachedFinallyBlocks_compute(v);
353      if(isFinal && num == state().boundariesCrossed){ isDUafterReachedFinallyBlocks_Variable_values.put(_parameters, Boolean.valueOf(isDUafterReachedFinallyBlocks_Variable_value)); }
354            return isDUafterReachedFinallyBlocks_Variable_value;
355      }
356      /**
357       * @apilevel internal
358       */
359      private boolean isDUafterReachedFinallyBlocks_compute(Variable v) {
360        if(!isDUbefore(v) && finallyList().isEmpty())
361          return false;
362        for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
363          FinallyHost f = (FinallyHost)iter.next();
364          if(!f.isDUafterFinally(v))
365            return false;
366        }
367        return true;
368      }
369      protected java.util.Map isDAafterReachedFinallyBlocks_Variable_values;
370      /**
371       * @attribute syn
372       * @aspect DU
373       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:953
374       */
375      @SuppressWarnings({"unchecked", "cast"})
376      public boolean isDAafterReachedFinallyBlocks(Variable v) {
377        Object _parameters = v;
378        if(isDAafterReachedFinallyBlocks_Variable_values == null) isDAafterReachedFinallyBlocks_Variable_values = new java.util.HashMap(4);
379        if(isDAafterReachedFinallyBlocks_Variable_values.containsKey(_parameters)) {
380          return ((Boolean)isDAafterReachedFinallyBlocks_Variable_values.get(_parameters)).booleanValue();
381        }
382          ASTNode$State state = state();
383      int num = state.boundariesCrossed;
384      boolean isFinal = this.is$Final();
385        boolean isDAafterReachedFinallyBlocks_Variable_value = isDAafterReachedFinallyBlocks_compute(v);
386      if(isFinal && num == state().boundariesCrossed){ isDAafterReachedFinallyBlocks_Variable_values.put(_parameters, Boolean.valueOf(isDAafterReachedFinallyBlocks_Variable_value)); }
387            return isDAafterReachedFinallyBlocks_Variable_value;
388      }
389      /**
390       * @apilevel internal
391       */
392      private boolean isDAafterReachedFinallyBlocks_compute(Variable v) {
393        if(isDAbefore(v))
394          return true;
395        if(finallyList().isEmpty())
396          return false;
397        for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
398          FinallyHost f = (FinallyHost)iter.next();
399          if(!f.isDAafterFinally(v))
400            return false;
401        }
402        return true;
403      }
404      protected java.util.Map isDUafter_Variable_values;
405      /**
406       * @attribute syn
407       * @aspect DU
408       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1170
409       */
410      @SuppressWarnings({"unchecked", "cast"})
411      public boolean isDUafter(Variable v) {
412        Object _parameters = v;
413        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
414        if(isDUafter_Variable_values.containsKey(_parameters)) {
415          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
416        }
417          ASTNode$State state = state();
418      int num = state.boundariesCrossed;
419      boolean isFinal = this.is$Final();
420        boolean isDUafter_Variable_value = isDUafter_compute(v);
421      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
422            return isDUafter_Variable_value;
423      }
424      /**
425       * @apilevel internal
426       */
427      private boolean isDUafter_compute(Variable v) {  return true;  }
428      /**
429       * @apilevel internal
430       */
431      protected boolean canCompleteNormally_computed = false;
432      /**
433       * @apilevel internal
434       */
435      protected boolean canCompleteNormally_value;
436      /**
437       * @attribute syn
438       * @aspect UnreachableStatements
439       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:105
440       */
441      @SuppressWarnings({"unchecked", "cast"})
442      public boolean canCompleteNormally() {
443        if(canCompleteNormally_computed) {
444          return canCompleteNormally_value;
445        }
446          ASTNode$State state = state();
447      int num = state.boundariesCrossed;
448      boolean isFinal = this.is$Final();
449        canCompleteNormally_value = canCompleteNormally_compute();
450      if(isFinal && num == state().boundariesCrossed){ canCompleteNormally_computed = true; }
451            return canCompleteNormally_value;
452      }
453      /**
454       * @apilevel internal
455       */
456      private boolean canCompleteNormally_compute() {  return false;  }
457      /**
458       * @attribute syn
459       * @aspect PreciseRethrow
460       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:55
461       */
462      public boolean modifiedInScope(Variable var) {
463        ASTNode$State state = state();
464        try {  return false;  }
465        finally {
466        }
467      }
468      protected java.util.Map lookupLabel_String_values;
469      /**
470       * @attribute inh
471       * @aspect BranchTarget
472       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:168
473       */
474      @SuppressWarnings({"unchecked", "cast"})
475      public LabeledStmt lookupLabel(String name) {
476        Object _parameters = name;
477        if(lookupLabel_String_values == null) lookupLabel_String_values = new java.util.HashMap(4);
478        if(lookupLabel_String_values.containsKey(_parameters)) {
479          return (LabeledStmt)lookupLabel_String_values.get(_parameters);
480        }
481          ASTNode$State state = state();
482      int num = state.boundariesCrossed;
483      boolean isFinal = this.is$Final();
484        LabeledStmt lookupLabel_String_value = getParent().Define_LabeledStmt_lookupLabel(this, null, name);
485      if(isFinal && num == state().boundariesCrossed){ lookupLabel_String_values.put(_parameters, lookupLabel_String_value); }
486            return lookupLabel_String_value;
487      }
488      /**
489       * @attribute inh
490       * @aspect NameCheck
491       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:365
492       */
493      @SuppressWarnings({"unchecked", "cast"})
494      public boolean insideLoop() {
495          ASTNode$State state = state();
496        boolean insideLoop_value = getParent().Define_boolean_insideLoop(this, null);
497            return insideLoop_value;
498      }
499      /**
500       * @attribute inh
501       * @aspect NameCheck
502       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:374
503       */
504      @SuppressWarnings({"unchecked", "cast"})
505      public boolean insideSwitch() {
506          ASTNode$State state = state();
507        boolean insideSwitch_value = getParent().Define_boolean_insideSwitch(this, null);
508            return insideSwitch_value;
509      }
510      /**
511       * @apilevel internal
512       */
513      public ASTNode rewriteTo() {
514        return super.rewriteTo();
515      }
516    }