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:199
027     * @production Case : {@link Stmt};
028    
029     */
030    public abstract class Case extends Stmt implements Cloneable {
031      /**
032       * @aspect CreateBCode
033       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1532
034       */
035      public void createBCode(CodeGeneration gen) {
036        gen.addLabel(label());
037      }
038      /**
039       * @declaredat ASTNode:1
040       */
041      public Case() {
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        isDAbefore_Variable_reset();
074        isDAafter_Variable_reset();
075        isDUafter_Variable_reset();
076        label_reset();
077        bind_Case_reset();
078      }
079      /**
080       * @apilevel internal
081       * @declaredat ASTNode:38
082       */
083      public void flushCollectionCache() {
084        super.flushCollectionCache();
085      }
086      /**
087       * @apilevel internal
088       * @declaredat ASTNode:44
089       */
090      public void flushRewriteCache() {
091        super.flushRewriteCache();
092      }
093      /**
094       * @apilevel internal
095       * @declaredat ASTNode:50
096       */
097      public Case clone() throws CloneNotSupportedException {
098        Case node = (Case) super.clone();
099        return node;
100      }
101      /**
102       * Create a deep copy of the AST subtree at this node.
103       * The copy is dangling, i.e. has no parent.
104       * @return dangling copy of the subtree at this node
105       * @apilevel low-level
106       * @deprecated Please use treeCopy or treeCopyNoTransform instead
107       * @declaredat ASTNode:61
108       */
109      @Deprecated
110      public abstract Case fullCopy();
111      /**
112       * Create a deep copy of the AST subtree at this node.
113       * The copy is dangling, i.e. has no parent.
114       * @return dangling copy of the subtree at this node
115       * @apilevel low-level
116       * @declaredat ASTNode:69
117       */
118      public abstract Case treeCopyNoTransform();
119      /**
120       * Create a deep copy of the AST subtree at this node.
121       * The subtree of this node is traversed to trigger rewrites before copy.
122       * The copy is dangling, i.e. has no parent.
123       * @return dangling copy of the subtree at this node
124       * @apilevel low-level
125       * @declaredat ASTNode:77
126       */
127      public abstract Case treeCopy();
128      /**
129       * @attribute syn
130       * @aspect NameCheck
131       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:512
132       */
133      @ASTNodeAnnotation.Attribute
134      public abstract boolean constValue(Case c);
135      /**
136       * @apilevel internal
137       */
138      protected java.util.Map isDAbefore_Variable_values;
139      /**
140       * @apilevel internal
141       */
142      private void isDAbefore_Variable_reset() {
143        isDAbefore_Variable_values = null;
144      }
145      /**
146       * @attribute syn
147       * @aspect DA
148       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:639
149       */
150      @ASTNodeAnnotation.Attribute
151      public boolean isDAbefore(Variable v) {
152        Object _parameters = v;
153        if (isDAbefore_Variable_values == null) isDAbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
154        ASTNode$State state = state();
155        if (isDAbefore_Variable_values.containsKey(_parameters)) {
156          return (Boolean) isDAbefore_Variable_values.get(_parameters);
157        }
158        boolean intermediate = state.INTERMEDIATE_VALUE;
159        state.INTERMEDIATE_VALUE = false;
160        int num = state.boundariesCrossed;
161        boolean isFinal = this.is$Final();
162        boolean isDAbefore_Variable_value = getParent().getParent() instanceof Block
163              && ((Block) getParent().getParent()).isDAbefore(v)
164              && super.isDAbefore(v);
165        if (isFinal && num == state().boundariesCrossed) {
166          isDAbefore_Variable_values.put(_parameters, isDAbefore_Variable_value);
167        } else {
168        }
169        state.INTERMEDIATE_VALUE |= intermediate;
170    
171        return isDAbefore_Variable_value;
172      }
173      /**
174       * @apilevel internal
175       */
176      protected java.util.Map isDAafter_Variable_values;
177      /**
178       * @apilevel internal
179       */
180      private void isDAafter_Variable_reset() {
181        isDAafter_Variable_values = null;
182      }
183      /**
184       * @attribute syn
185       * @aspect DA
186       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257
187       */
188      @ASTNodeAnnotation.Attribute
189      public boolean isDAafter(Variable v) {
190        Object _parameters = v;
191        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
192        ASTNode$State state = state();
193        if (isDAafter_Variable_values.containsKey(_parameters)) {
194          return (Boolean) isDAafter_Variable_values.get(_parameters);
195        }
196        boolean intermediate = state.INTERMEDIATE_VALUE;
197        state.INTERMEDIATE_VALUE = false;
198        int num = state.boundariesCrossed;
199        boolean isFinal = this.is$Final();
200        boolean isDAafter_Variable_value = isDAbefore(v);
201        if (isFinal && num == state().boundariesCrossed) {
202          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
203        } else {
204        }
205        state.INTERMEDIATE_VALUE |= intermediate;
206    
207        return isDAafter_Variable_value;
208      }
209      /**
210       * @attribute syn
211       * @aspect DU
212       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1187
213       */
214      @ASTNodeAnnotation.Attribute
215      public boolean isDUbefore(Variable v) {
216        boolean isDUbefore_Variable_value = getParent().getParent() instanceof Block
217              && ((Block) getParent().getParent()).isDUbefore(v)
218              && super.isDUbefore(v);
219    
220        return isDUbefore_Variable_value;
221      }
222      /**
223       * @apilevel internal
224       */
225      protected java.util.Map isDUafter_Variable_values;
226      /**
227       * @apilevel internal
228       */
229      private void isDUafter_Variable_reset() {
230        isDUafter_Variable_values = null;
231      }
232      /**
233       * @attribute syn
234       * @aspect DU
235       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781
236       */
237      @ASTNodeAnnotation.Attribute
238      public boolean isDUafter(Variable v) {
239        Object _parameters = v;
240        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
241        ASTNode$State state = state();
242        if (isDUafter_Variable_values.containsKey(_parameters)) {
243          return (Boolean) isDUafter_Variable_values.get(_parameters);
244        }
245        boolean intermediate = state.INTERMEDIATE_VALUE;
246        state.INTERMEDIATE_VALUE = false;
247        int num = state.boundariesCrossed;
248        boolean isFinal = this.is$Final();
249        boolean isDUafter_Variable_value = isDUbefore(v);
250        if (isFinal && num == state().boundariesCrossed) {
251          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
252        } else {
253        }
254        state.INTERMEDIATE_VALUE |= intermediate;
255    
256        return isDUafter_Variable_value;
257      }
258      /**
259       * @attribute syn
260       * @aspect UnreachableStatements
261       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:129
262       */
263      @ASTNodeAnnotation.Attribute
264      public boolean reachable() {
265        boolean reachable_value = getParent().getParent() instanceof Block && ((Block) getParent().getParent()).reachable();
266    
267        return reachable_value;
268      }
269      /**
270       * @apilevel internal
271       */
272      protected boolean label_computed = false;
273      /**
274       * @apilevel internal
275       */
276      protected int label_value;
277      /**
278       * @apilevel internal
279       */
280      private void label_reset() {
281        label_computed = false;
282      }
283      /**
284       * @attribute syn
285       * @aspect CreateBCode
286       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1530
287       */
288      @ASTNodeAnnotation.Attribute
289      public int label() {
290        ASTNode$State state = state();
291        if (label_computed) {
292          return label_value;
293        }
294        boolean intermediate = state.INTERMEDIATE_VALUE;
295        state.INTERMEDIATE_VALUE = false;
296        int num = state.boundariesCrossed;
297        boolean isFinal = this.is$Final();
298        label_value = hostType().constantPool().newLabel();
299        if (isFinal && num == state().boundariesCrossed) {
300          label_computed = true;
301        } else {
302        }
303        state.INTERMEDIATE_VALUE |= intermediate;
304    
305        return label_value;
306      }
307      /**
308       * @attribute syn
309       * @aspect PreciseRethrow
310       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84
311       */
312      @ASTNodeAnnotation.Attribute
313      public boolean modifiedInScope(Variable var) {
314        boolean modifiedInScope_Variable_value = false;
315    
316        return modifiedInScope_Variable_value;
317      }
318      /**
319       * @attribute syn
320       * @aspect StringsInSwitch
321       * @declaredat /home/jesper/git/extendj/java7/frontend/StringsInSwitch.jrag:59
322       */
323      @ASTNodeAnnotation.Attribute
324      public boolean isDefaultCase() {
325        boolean isDefaultCase_value = false;
326    
327        return isDefaultCase_value;
328      }
329      /**
330       * @attribute inh
331       * @aspect NameCheck
332       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:496
333       */
334      /**
335       * @attribute inh
336       * @aspect NameCheck
337       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:496
338       */
339      @ASTNodeAnnotation.Attribute
340      public Case bind(Case c) {
341        Object _parameters = c;
342        if (bind_Case_values == null) bind_Case_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
343        ASTNode$State state = state();
344        if (bind_Case_values.containsKey(_parameters)) {
345          return (Case) bind_Case_values.get(_parameters);
346        }
347        boolean intermediate = state.INTERMEDIATE_VALUE;
348        state.INTERMEDIATE_VALUE = false;
349        int num = state.boundariesCrossed;
350        boolean isFinal = this.is$Final();
351        Case bind_Case_value = getParent().Define_bind(this, null, c);
352        if (isFinal && num == state().boundariesCrossed) {
353          bind_Case_values.put(_parameters, bind_Case_value);
354        } else {
355        }
356        state.INTERMEDIATE_VALUE |= intermediate;
357    
358        return bind_Case_value;
359      }
360      /**
361       * @apilevel internal
362       */
363      protected java.util.Map bind_Case_values;
364      /**
365       * @apilevel internal
366       */
367      private void bind_Case_reset() {
368        bind_Case_values = null;
369      }
370      /**
371       * @attribute inh
372       * @aspect TypeCheck
373       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:420
374       */
375      /**
376       * @attribute inh
377       * @aspect TypeCheck
378       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:420
379       */
380      @ASTNodeAnnotation.Attribute
381      public TypeDecl switchType() {
382        TypeDecl switchType_value = getParent().Define_switchType(this, null);
383    
384        return switchType_value;
385      }
386      /**
387       * @apilevel internal
388       */
389      public ASTNode rewriteTo() {
390        return super.rewriteTo();
391      }
392    }