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