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:195
027     * @production LabeledStmt : {@link BranchTargetStmt} ::= <span class="component">&lt;Label:String&gt;</span> <span class="component">{@link Stmt}</span>;
028    
029     */
030    public class LabeledStmt extends BranchTargetStmt implements Cloneable {
031      /**
032       * @aspect NameCheck
033       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:431
034       */
035      public void nameCheck() {
036        LabeledStmt stmt = lookupLabel(getLabel());
037        if (stmt != null) {
038          if (stmt.enclosingBodyDecl() == enclosingBodyDecl()) {
039            error("Labels can not shadow labels in the same member");
040          }
041        }
042      }
043      /**
044       * @aspect Java4PrettyPrint
045       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:155
046       */
047      public void prettyPrint(PrettyPrinter out) {
048        out.print(getLabel());
049        out.print(":");
050      }
051      /**
052       * @aspect CreateBCode
053       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1382
054       */
055      public void createBCode(CodeGeneration gen) {
056        super.createBCode(gen);
057        gen.addLabel(label());
058        getStmt().createBCode(gen);
059        gen.addLabel(end_label());
060      }
061      /**
062       * @declaredat ASTNode:1
063       */
064      public LabeledStmt() {
065        super();
066      }
067      /**
068       * Initializes the child array to the correct size.
069       * Initializes List and Opt nta children.
070       * @apilevel internal
071       * @ast method
072       * @declaredat ASTNode:10
073       */
074      public void init$Children() {
075        children = new ASTNode[1];
076      }
077      /**
078       * @declaredat ASTNode:13
079       */
080      public LabeledStmt(String p0, Stmt p1) {
081        setLabel(p0);
082        setChild(p1, 0);
083      }
084      /**
085       * @declaredat ASTNode:17
086       */
087      public LabeledStmt(beaver.Symbol p0, Stmt p1) {
088        setLabel(p0);
089        setChild(p1, 0);
090      }
091      /**
092       * @apilevel low-level
093       * @declaredat ASTNode:24
094       */
095      protected int numChildren() {
096        return 1;
097      }
098      /**
099       * @apilevel internal
100       * @declaredat ASTNode:30
101       */
102      public boolean mayHaveRewrite() {
103        return false;
104      }
105      /**
106       * @apilevel internal
107       * @declaredat ASTNode:36
108       */
109      public void flushAttrCache() {
110        super.flushAttrCache();
111        isDAafter_Variable_reset();
112        isDUafter_Variable_reset();
113        canCompleteNormally_reset();
114        label_reset();
115        end_label_reset();
116        lookupLabel_String_reset();
117      }
118      /**
119       * @apilevel internal
120       * @declaredat ASTNode:48
121       */
122      public void flushCollectionCache() {
123        super.flushCollectionCache();
124      }
125      /**
126       * @apilevel internal
127       * @declaredat ASTNode:54
128       */
129      public void flushRewriteCache() {
130        super.flushRewriteCache();
131      }
132      /**
133       * @apilevel internal
134       * @declaredat ASTNode:60
135       */
136      public LabeledStmt clone() throws CloneNotSupportedException {
137        LabeledStmt node = (LabeledStmt) super.clone();
138        return node;
139      }
140      /**
141       * @apilevel internal
142       * @declaredat ASTNode:67
143       */
144      public LabeledStmt copy() {
145        try {
146          LabeledStmt node = (LabeledStmt) clone();
147          node.parent = null;
148          if (children != null) {
149            node.children = (ASTNode[]) children.clone();
150          }
151          return node;
152        } catch (CloneNotSupportedException e) {
153          throw new Error("Error: clone not supported for " + getClass().getName());
154        }
155      }
156      /**
157       * Create a deep copy of the AST subtree at this node.
158       * The copy is dangling, i.e. has no parent.
159       * @return dangling copy of the subtree at this node
160       * @apilevel low-level
161       * @deprecated Please use treeCopy or treeCopyNoTransform instead
162       * @declaredat ASTNode:86
163       */
164      @Deprecated
165      public LabeledStmt fullCopy() {
166        return treeCopyNoTransform();
167      }
168      /**
169       * Create a deep copy of the AST subtree at this node.
170       * The copy is dangling, i.e. has no parent.
171       * @return dangling copy of the subtree at this node
172       * @apilevel low-level
173       * @declaredat ASTNode:96
174       */
175      public LabeledStmt treeCopyNoTransform() {
176        LabeledStmt tree = (LabeledStmt) copy();
177        if (children != null) {
178          for (int i = 0; i < children.length; ++i) {
179            ASTNode child = (ASTNode) children[i];
180            if (child != null) {
181              child = child.treeCopyNoTransform();
182              tree.setChild(child, i);
183            }
184          }
185        }
186        return tree;
187      }
188      /**
189       * Create a deep copy of the AST subtree at this node.
190       * The subtree of this node is traversed to trigger rewrites before copy.
191       * The copy is dangling, i.e. has no parent.
192       * @return dangling copy of the subtree at this node
193       * @apilevel low-level
194       * @declaredat ASTNode:116
195       */
196      public LabeledStmt treeCopy() {
197        doFullTraversal();
198        return treeCopyNoTransform();
199      }
200      /**
201       * @apilevel internal
202       * @declaredat ASTNode:123
203       */
204      protected boolean is$Equal(ASTNode node) {
205        return super.is$Equal(node) && (tokenString_Label == ((LabeledStmt)node).tokenString_Label);    
206      }
207      /**
208       * Replaces the lexeme Label.
209       * @param value The new value for the lexeme Label.
210       * @apilevel high-level
211       */
212      public void setLabel(String value) {
213        tokenString_Label = value;
214      }
215      /**
216       * @apilevel internal
217       */
218      protected String tokenString_Label;
219      /**
220       */
221      public int Labelstart;
222      /**
223       */
224      public int Labelend;
225      /**
226       * JastAdd-internal setter for lexeme Label using the Beaver parser.
227       * @param symbol Symbol containing the new value for the lexeme Label
228       * @apilevel internal
229       */
230      public void setLabel(beaver.Symbol symbol) {
231        if (symbol.value != null && !(symbol.value instanceof String))
232        throw new UnsupportedOperationException("setLabel is only valid for String lexemes");
233        tokenString_Label = (String)symbol.value;
234        Labelstart = symbol.getStart();
235        Labelend = symbol.getEnd();
236      }
237      /**
238       * Retrieves the value for the lexeme Label.
239       * @return The value for the lexeme Label.
240       * @apilevel high-level
241       */
242      @ASTNodeAnnotation.Token(name="Label")
243      public String getLabel() {
244        return tokenString_Label != null ? tokenString_Label : "";
245      }
246      /**
247       * Replaces the Stmt child.
248       * @param node The new node to replace the Stmt child.
249       * @apilevel high-level
250       */
251      public void setStmt(Stmt node) {
252        setChild(node, 0);
253      }
254      /**
255       * Retrieves the Stmt child.
256       * @return The current node used as the Stmt child.
257       * @apilevel high-level
258       */
259      @ASTNodeAnnotation.Child(name="Stmt")
260      public Stmt getStmt() {
261        return (Stmt) getChild(0);
262      }
263      /**
264       * Retrieves the Stmt child.
265       * <p><em>This method does not invoke AST transformations.</em></p>
266       * @return The current node used as the Stmt child.
267       * @apilevel low-level
268       */
269      public Stmt getStmtNoTransform() {
270        return (Stmt) getChildNoTransform(0);
271      }
272      /**
273       * @return <code>true</code> if this statement is a potential
274       * branch target of the given branch statement.
275       * @attribute syn
276       * @aspect BranchTarget
277       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:217
278       */
279      @ASTNodeAnnotation.Attribute
280      public boolean potentialTargetOf(Stmt branch) {
281        boolean potentialTargetOf_Stmt_value = branch.canBranchTo(this);
282    
283        return potentialTargetOf_Stmt_value;
284      }
285      /**
286       * @apilevel internal
287       */
288      protected java.util.Map isDAafter_Variable_values;
289      /**
290       * @apilevel internal
291       */
292      private void isDAafter_Variable_reset() {
293        isDAafter_Variable_values = null;
294      }
295      /**
296       * @attribute syn
297       * @aspect DA
298       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257
299       */
300      @ASTNodeAnnotation.Attribute
301      public boolean isDAafter(Variable v) {
302        Object _parameters = v;
303        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
304        ASTNode$State state = state();
305        if (isDAafter_Variable_values.containsKey(_parameters)) {
306          return (Boolean) isDAafter_Variable_values.get(_parameters);
307        }
308        boolean intermediate = state.INTERMEDIATE_VALUE;
309        state.INTERMEDIATE_VALUE = false;
310        int num = state.boundariesCrossed;
311        boolean isFinal = this.is$Final();
312        boolean isDAafter_Variable_value = isDAafter_compute(v);
313        if (isFinal && num == state().boundariesCrossed) {
314          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
315        } else {
316        }
317        state.INTERMEDIATE_VALUE |= intermediate;
318    
319        return isDAafter_Variable_value;
320      }
321      /**
322       * @apilevel internal
323       */
324      private boolean isDAafter_compute(Variable v) {
325          if (!getStmt().isDAafter(v)) {
326            return false;
327          }
328          for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
329            BreakStmt stmt = (BreakStmt) iter.next();
330            if (!stmt.isDAafterReachedFinallyBlocks(v)) {
331              return false;
332            }
333          }
334          return true;
335        }
336      /**
337       * @apilevel internal
338       */
339      protected java.util.Map isDUafter_Variable_values;
340      /**
341       * @apilevel internal
342       */
343      private void isDUafter_Variable_reset() {
344        isDUafter_Variable_values = null;
345      }
346      /**
347       * @attribute syn
348       * @aspect DU
349       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781
350       */
351      @ASTNodeAnnotation.Attribute
352      public boolean isDUafter(Variable v) {
353        Object _parameters = v;
354        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
355        ASTNode$State state = state();
356        if (isDUafter_Variable_values.containsKey(_parameters)) {
357          return (Boolean) isDUafter_Variable_values.get(_parameters);
358        }
359        boolean intermediate = state.INTERMEDIATE_VALUE;
360        state.INTERMEDIATE_VALUE = false;
361        int num = state.boundariesCrossed;
362        boolean isFinal = this.is$Final();
363        boolean isDUafter_Variable_value = isDUafter_compute(v);
364        if (isFinal && num == state().boundariesCrossed) {
365          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
366        } else {
367        }
368        state.INTERMEDIATE_VALUE |= intermediate;
369    
370        return isDUafter_Variable_value;
371      }
372      /**
373       * @apilevel internal
374       */
375      private boolean isDUafter_compute(Variable v) {
376          if (!getStmt().isDUafter(v)) {
377            return false;
378          }
379          for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
380            BreakStmt stmt = (BreakStmt) iter.next();
381            if (!stmt.isDUafterReachedFinallyBlocks(v)) {
382              return false;
383            }
384          }
385          return true;
386        }
387      /**
388       * @apilevel internal
389       */
390      protected boolean canCompleteNormally_computed = false;
391      /**
392       * @apilevel internal
393       */
394      protected boolean canCompleteNormally_value;
395      /**
396       * @apilevel internal
397       */
398      private void canCompleteNormally_reset() {
399        canCompleteNormally_computed = false;
400      }
401      /**
402       * @attribute syn
403       * @aspect UnreachableStatements
404       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53
405       */
406      @ASTNodeAnnotation.Attribute
407      public boolean canCompleteNormally() {
408        ASTNode$State state = state();
409        if (canCompleteNormally_computed) {
410          return canCompleteNormally_value;
411        }
412        boolean intermediate = state.INTERMEDIATE_VALUE;
413        state.INTERMEDIATE_VALUE = false;
414        int num = state.boundariesCrossed;
415        boolean isFinal = this.is$Final();
416        canCompleteNormally_value = getStmt().canCompleteNormally() || reachableBreak();
417        if (isFinal && num == state().boundariesCrossed) {
418          canCompleteNormally_computed = true;
419        } else {
420        }
421        state.INTERMEDIATE_VALUE |= intermediate;
422    
423        return canCompleteNormally_value;
424      }
425      /**
426       * @apilevel internal
427       */
428      protected boolean label_computed = false;
429      /**
430       * @apilevel internal
431       */
432      protected int label_value;
433      /**
434       * @apilevel internal
435       */
436      private void label_reset() {
437        label_computed = false;
438      }
439      /**
440       * @attribute syn
441       * @aspect CreateBCode
442       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1380
443       */
444      @ASTNodeAnnotation.Attribute
445      public int label() {
446        ASTNode$State state = state();
447        if (label_computed) {
448          return label_value;
449        }
450        boolean intermediate = state.INTERMEDIATE_VALUE;
451        state.INTERMEDIATE_VALUE = false;
452        int num = state.boundariesCrossed;
453        boolean isFinal = this.is$Final();
454        label_value = hostType().constantPool().newLabel();
455        if (isFinal && num == state().boundariesCrossed) {
456          label_computed = true;
457        } else {
458        }
459        state.INTERMEDIATE_VALUE |= intermediate;
460    
461        return label_value;
462      }
463      /**
464       * @apilevel internal
465       */
466      protected boolean end_label_computed = false;
467      /**
468       * @apilevel internal
469       */
470      protected int end_label_value;
471      /**
472       * @apilevel internal
473       */
474      private void end_label_reset() {
475        end_label_computed = false;
476      }
477      /**
478       * @attribute syn
479       * @aspect CreateBCode
480       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1381
481       */
482      @ASTNodeAnnotation.Attribute
483      public int end_label() {
484        ASTNode$State state = state();
485        if (end_label_computed) {
486          return end_label_value;
487        }
488        boolean intermediate = state.INTERMEDIATE_VALUE;
489        state.INTERMEDIATE_VALUE = false;
490        int num = state.boundariesCrossed;
491        boolean isFinal = this.is$Final();
492        end_label_value = hostType().constantPool().newLabel();
493        if (isFinal && num == state().boundariesCrossed) {
494          end_label_computed = true;
495        } else {
496        }
497        state.INTERMEDIATE_VALUE |= intermediate;
498    
499        return end_label_value;
500      }
501      /**
502       * @attribute syn
503       * @aspect CreateBCode
504       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1621
505       */
506      @ASTNodeAnnotation.Attribute
507      public int break_label() {
508        int break_label_value = end_label();
509    
510        return break_label_value;
511      }
512      /**
513       * @attribute syn
514       * @aspect CreateBCode
515       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1645
516       */
517      @ASTNodeAnnotation.Attribute
518      public int continue_label() {
519        int continue_label_value = getStmt().continue_label();
520    
521        return continue_label_value;
522      }
523      /**
524       * @attribute syn
525       * @aspect PreciseRethrow
526       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84
527       */
528      @ASTNodeAnnotation.Attribute
529      public boolean modifiedInScope(Variable var) {
530        boolean modifiedInScope_Variable_value = getStmt().modifiedInScope(var);
531    
532        return modifiedInScope_Variable_value;
533      }
534      /**
535       * @attribute inh
536       * @aspect BranchTarget
537       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:251
538       */
539      /**
540       * @attribute inh
541       * @aspect BranchTarget
542       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:251
543       */
544      @ASTNodeAnnotation.Attribute
545      public LabeledStmt lookupLabel(String name) {
546        Object _parameters = name;
547        if (lookupLabel_String_values == null) lookupLabel_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
548        ASTNode$State state = state();
549        if (lookupLabel_String_values.containsKey(_parameters)) {
550          return (LabeledStmt) lookupLabel_String_values.get(_parameters);
551        }
552        boolean intermediate = state.INTERMEDIATE_VALUE;
553        state.INTERMEDIATE_VALUE = false;
554        int num = state.boundariesCrossed;
555        boolean isFinal = this.is$Final();
556        LabeledStmt lookupLabel_String_value = getParent().Define_lookupLabel(this, null, name);
557        if (isFinal && num == state().boundariesCrossed) {
558          lookupLabel_String_values.put(_parameters, lookupLabel_String_value);
559        } else {
560        }
561        state.INTERMEDIATE_VALUE |= intermediate;
562    
563        return lookupLabel_String_value;
564      }
565      /**
566       * @apilevel internal
567       */
568      protected java.util.Map lookupLabel_String_values;
569      /**
570       * @apilevel internal
571       */
572      private void lookupLabel_String_reset() {
573        lookupLabel_String_values = null;
574      }
575      /**
576       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227
577       * @apilevel internal
578       */
579      public Stmt Define_branchTarget(ASTNode caller, ASTNode child, Stmt branch) {
580        int childIndex = this.getIndexOfChild(caller);
581        return branch.canBranchTo(this) ? this : branchTarget(branch);
582      }
583      protected boolean canDefine_branchTarget(ASTNode caller, ASTNode child, Stmt branch) {
584        return true;
585      }
586      /**
587       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:250
588       * @apilevel internal
589       */
590      public LabeledStmt Define_lookupLabel(ASTNode caller, ASTNode child, String name) {
591        if (caller == getStmtNoTransform()) {
592          // @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:252
593          return name.equals(getLabel()) ? this : lookupLabel(name);
594        }
595        else {
596          return getParent().Define_lookupLabel(this, caller, name);
597        }
598      }
599      protected boolean canDefine_lookupLabel(ASTNode caller, ASTNode child, String name) {
600        return true;
601      }
602      /**
603       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
604       * @apilevel internal
605       */
606      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
607        if (caller == getStmtNoTransform()) {
608          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:573
609          return isDAbefore(v);
610        }
611        else {
612          return getParent().Define_isDAbefore(this, caller, v);
613        }
614      }
615      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
616        return true;
617      }
618      /**
619       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
620       * @apilevel internal
621       */
622      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
623        if (caller == getStmtNoTransform()) {
624          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1018
625          return isDUbefore(v);
626        }
627        else {
628          return getParent().Define_isDUbefore(this, caller, v);
629        }
630      }
631      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
632        return true;
633      }
634      /**
635       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52
636       * @apilevel internal
637       */
638      public boolean Define_reachable(ASTNode caller, ASTNode child) {
639        if (caller == getStmtNoTransform()) {
640          // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:84
641          return reachable();
642        }
643        else {
644          return getParent().Define_reachable(this, caller);
645        }
646      }
647      protected boolean canDefine_reachable(ASTNode caller, ASTNode child) {
648        return true;
649      }
650      /**
651       * @apilevel internal
652       */
653      public ASTNode rewriteTo() {
654        return super.rewriteTo();
655      }
656    }