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:191
027     * @production Stmt : {@link ASTNode};
028    
029     */
030    public abstract class Stmt extends ASTNode<ASTNode> implements Cloneable {
031      /**
032       * @return An Opt node containing the finally and monitor exit blocks
033       * from the list of enclosing try-statements and synchronized blocks.
034       * @aspect NTAFinally
035       * @declaredat /home/jesper/git/extendj/java4/frontend/NTAFinally.jrag:82
036       */
037      public Opt<Block> branchFinallyOpt() {
038        FinallyHost enclosing = enclosingFinally(this);
039        if (enclosing != null) {
040          return new Opt<Block>(ntaFinallyBlock(enclosing, this, enclosing.getFinallyBlock()));
041        } else {
042          return new Opt<Block>();
043        }
044      }
045      /**
046       * @aspect UnreachableStatements
047       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:35
048       */
049      void checkUnreachableStmt() {
050        if (!reachable() && reportUnreachable()) {
051          error("statement is unreachable");
052        }
053      }
054      /**
055       * @aspect CreateBCode
056       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1359
057       */
058      public void createBCode(CodeGeneration gen) {
059        gen.addLineNumberEntryAtCurrentPC(this);
060      }
061      /**
062       * @declaredat ASTNode:1
063       */
064      public Stmt() {
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      }
076      /**
077       * @apilevel low-level
078       * @declaredat ASTNode:15
079       */
080      protected int numChildren() {
081        return 0;
082      }
083      /**
084       * @apilevel internal
085       * @declaredat ASTNode:21
086       */
087      public boolean mayHaveRewrite() {
088        return false;
089      }
090      /**
091       * @apilevel internal
092       * @declaredat ASTNode:27
093       */
094      public void flushAttrCache() {
095        super.flushAttrCache();
096        finallyIterator_reset();
097        isDAafter_Variable_reset();
098        isDUafter_Variable_reset();
099        canCompleteNormally_reset();
100        localSize_reset();
101        enclosingFinally_Stmt_reset();
102        localNum_reset();
103      }
104      /**
105       * @apilevel internal
106       * @declaredat ASTNode:40
107       */
108      public void flushCollectionCache() {
109        super.flushCollectionCache();
110      }
111      /**
112       * @apilevel internal
113       * @declaredat ASTNode:46
114       */
115      public void flushRewriteCache() {
116        super.flushRewriteCache();
117      }
118      /**
119       * @apilevel internal
120       * @declaredat ASTNode:52
121       */
122      public Stmt clone() throws CloneNotSupportedException {
123        Stmt node = (Stmt) super.clone();
124        return node;
125      }
126      /**
127       * Create a deep copy of the AST subtree at this node.
128       * The copy is dangling, i.e. has no parent.
129       * @return dangling copy of the subtree at this node
130       * @apilevel low-level
131       * @deprecated Please use treeCopy or treeCopyNoTransform instead
132       * @declaredat ASTNode:63
133       */
134      @Deprecated
135      public abstract Stmt fullCopy();
136      /**
137       * Create a deep copy of the AST subtree at this node.
138       * The copy is dangling, i.e. has no parent.
139       * @return dangling copy of the subtree at this node
140       * @apilevel low-level
141       * @declaredat ASTNode:71
142       */
143      public abstract Stmt treeCopyNoTransform();
144      /**
145       * Create a deep copy of the AST subtree at this node.
146       * The subtree of this node is traversed to trigger rewrites before copy.
147       * The copy is dangling, i.e. has no parent.
148       * @return dangling copy of the subtree at this node
149       * @apilevel low-level
150       * @declaredat ASTNode:79
151       */
152      public abstract Stmt treeCopy();
153      /**
154       * @attribute syn
155       * @aspect PreciseRethrow
156       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84
157       */
158      @ASTNodeAnnotation.Attribute
159      public abstract boolean modifiedInScope(Variable var);
160      /**
161       * @apilevel internal
162       */
163      protected boolean finallyIterator_computed = false;
164      /**
165       * @apilevel internal
166       */
167      protected Iterator<FinallyHost> finallyIterator_value;
168      /**
169       * @apilevel internal
170       */
171      private void finallyIterator_reset() {
172        finallyIterator_computed = false;
173        finallyIterator_value = null;
174      }
175      /**
176       * Finds enclosing finally and monitor exit blocks.
177       * @return an iterator for finally (and monitor exit) blocks that are
178       * reached before the final target of this statement is reached
179       * @attribute syn
180       * @aspect BranchTarget
181       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:80
182       */
183      @ASTNodeAnnotation.Attribute
184      public Iterator<FinallyHost> finallyIterator() {
185        ASTNode$State state = state();
186        if (finallyIterator_computed) {
187          return finallyIterator_value;
188        }
189        boolean intermediate = state.INTERMEDIATE_VALUE;
190        state.INTERMEDIATE_VALUE = false;
191        int num = state.boundariesCrossed;
192        boolean isFinal = this.is$Final();
193        finallyIterator_value = finallyIterator_compute();
194        if (isFinal && num == state().boundariesCrossed) {
195          finallyIterator_computed = true;
196        } else {
197        }
198        state.INTERMEDIATE_VALUE |= intermediate;
199    
200        return finallyIterator_value;
201      }
202      /**
203       * @apilevel internal
204       */
205      private Iterator<FinallyHost> finallyIterator_compute() {
206          return new LazyFinallyIterator(this);
207        }
208      /**
209       * @return <code>true</code> if this statement can branch to
210       * the target statement.
211       * @attribute syn
212       * @aspect BranchTarget
213       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:187
214       */
215      @ASTNodeAnnotation.Attribute
216      public boolean canBranchTo(BranchTargetStmt target) {
217        boolean canBranchTo_BranchTargetStmt_value = false;
218    
219        return canBranchTo_BranchTargetStmt_value;
220      }
221      /**
222       * @attribute syn
223       * @aspect BranchTarget
224       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:188
225       */
226      @ASTNodeAnnotation.Attribute
227      public boolean canBranchTo(LabeledStmt target) {
228        boolean canBranchTo_LabeledStmt_value = false;
229    
230        return canBranchTo_LabeledStmt_value;
231      }
232      /**
233       * @attribute syn
234       * @aspect BranchTarget
235       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:189
236       */
237      @ASTNodeAnnotation.Attribute
238      public boolean canBranchTo(SwitchStmt target) {
239        boolean canBranchTo_SwitchStmt_value = false;
240    
241        return canBranchTo_SwitchStmt_value;
242      }
243      /**
244       * @apilevel internal
245       */
246      protected java.util.Map isDAafter_Variable_values;
247      /**
248       * @apilevel internal
249       */
250      private void isDAafter_Variable_reset() {
251        isDAafter_Variable_values = null;
252      }
253      /**
254       * @attribute syn
255       * @aspect DA
256       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257
257       */
258      @ASTNodeAnnotation.Attribute
259      public boolean isDAafter(Variable v) {
260        Object _parameters = v;
261        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
262        ASTNode$State state = state();
263        if (isDAafter_Variable_values.containsKey(_parameters)) {
264          return (Boolean) isDAafter_Variable_values.get(_parameters);
265        }
266        boolean intermediate = state.INTERMEDIATE_VALUE;
267        state.INTERMEDIATE_VALUE = false;
268        int num = state.boundariesCrossed;
269        boolean isFinal = this.is$Final();
270        boolean isDAafter_Variable_value = isDAbefore(v);
271        if (isFinal && num == state().boundariesCrossed) {
272          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
273        } else {
274        }
275        state.INTERMEDIATE_VALUE |= intermediate;
276    
277        return isDAafter_Variable_value;
278      }
279      /**
280       * @apilevel internal
281       */
282      protected java.util.Map isDUafter_Variable_values;
283      /**
284       * @apilevel internal
285       */
286      private void isDUafter_Variable_reset() {
287        isDUafter_Variable_values = null;
288      }
289      /**
290       * @attribute syn
291       * @aspect DU
292       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781
293       */
294      @ASTNodeAnnotation.Attribute
295      public boolean isDUafter(Variable v) {
296        Object _parameters = v;
297        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
298        ASTNode$State state = state();
299        if (isDUafter_Variable_values.containsKey(_parameters)) {
300          return (Boolean) isDUafter_Variable_values.get(_parameters);
301        }
302        boolean intermediate = state.INTERMEDIATE_VALUE;
303        state.INTERMEDIATE_VALUE = false;
304        int num = state.boundariesCrossed;
305        boolean isFinal = this.is$Final();
306        boolean isDUafter_Variable_value = isDUafter_compute(v);
307        if (isFinal && num == state().boundariesCrossed) {
308          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
309        } else {
310        }
311        state.INTERMEDIATE_VALUE |= intermediate;
312    
313        return isDUafter_Variable_value;
314      }
315      /**
316       * @apilevel internal
317       */
318      private boolean isDUafter_compute(Variable v) {
319          throw new Error("isDUafter in " + getClass().getName());
320        }
321      /**
322       * @attribute syn
323       * @aspect VariableScope
324       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:205
325       */
326      @ASTNodeAnnotation.Attribute
327      public VariableDeclaration variableDeclaration(String name) {
328        VariableDeclaration variableDeclaration_String_value = null;
329    
330        return variableDeclaration_String_value;
331      }
332      /**
333       * @attribute syn
334       * @aspect NameCheck
335       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:478
336       */
337      @ASTNodeAnnotation.Attribute
338      public boolean continueLabel() {
339        boolean continueLabel_value = false;
340    
341        return continueLabel_value;
342      }
343      /**
344       * @apilevel internal
345       */
346      protected boolean canCompleteNormally_computed = false;
347      /**
348       * @apilevel internal
349       */
350      protected boolean canCompleteNormally_value;
351      /**
352       * @apilevel internal
353       */
354      private void canCompleteNormally_reset() {
355        canCompleteNormally_computed = false;
356      }
357      /**
358       * @attribute syn
359       * @aspect UnreachableStatements
360       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53
361       */
362      @ASTNodeAnnotation.Attribute
363      public boolean canCompleteNormally() {
364        ASTNode$State state = state();
365        if (canCompleteNormally_computed) {
366          return canCompleteNormally_value;
367        }
368        boolean intermediate = state.INTERMEDIATE_VALUE;
369        state.INTERMEDIATE_VALUE = false;
370        int num = state.boundariesCrossed;
371        boolean isFinal = this.is$Final();
372        canCompleteNormally_value = true;
373        if (isFinal && num == state().boundariesCrossed) {
374          canCompleteNormally_computed = true;
375        } else {
376        }
377        state.INTERMEDIATE_VALUE |= intermediate;
378    
379        return canCompleteNormally_value;
380      }
381      /**
382       * @attribute syn
383       * @aspect CreateBCode
384       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1621
385       */
386      @ASTNodeAnnotation.Attribute
387      public int break_label() {
388        {
389            throw new UnsupportedOperationException("Can not break at this statement of type " + getClass().getName());
390          }
391      }
392      /**
393       * @attribute syn
394       * @aspect CreateBCode
395       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1645
396       */
397      @ASTNodeAnnotation.Attribute
398      public int continue_label() {
399        {
400            throw new UnsupportedOperationException("Can not continue at this statement");
401          }
402      }
403      /**
404       * @apilevel internal
405       */
406      protected boolean localSize_computed = false;
407      /**
408       * @apilevel internal
409       */
410      protected int localSize_value;
411      /**
412       * @apilevel internal
413       */
414      private void localSize_reset() {
415        localSize_computed = false;
416      }
417      /**
418       * Computes size required for local variables of this statement.
419       * NB: only relevant for variable declaration statements.
420       * @return local size for declared variables
421       * @attribute syn
422       * @aspect LocalNum
423       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:38
424       */
425      @ASTNodeAnnotation.Attribute
426      public int localSize() {
427        ASTNode$State state = state();
428        if (localSize_computed) {
429          return localSize_value;
430        }
431        boolean intermediate = state.INTERMEDIATE_VALUE;
432        state.INTERMEDIATE_VALUE = false;
433        int num = state.boundariesCrossed;
434        boolean isFinal = this.is$Final();
435        localSize_value = 0;
436        if (isFinal && num == state().boundariesCrossed) {
437          localSize_computed = true;
438        } else {
439        }
440        state.INTERMEDIATE_VALUE |= intermediate;
441    
442        return localSize_value;
443      }
444      /**
445       * @return the target statement for a break or continue
446       * @attribute inh
447       * @aspect BranchTarget
448       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227
449       */
450      /**
451       * @return the target statement for a break or continue
452       * @attribute inh
453       * @aspect BranchTarget
454       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227
455       */
456      @ASTNodeAnnotation.Attribute
457      public Stmt branchTarget(Stmt branch) {
458        Stmt branchTarget_Stmt_value = getParent().Define_branchTarget(this, null, branch);
459    
460        return branchTarget_Stmt_value;
461      }
462      /**
463       * Find finally block of enclosing try-statement, or monitor exit
464       * block of enclosing synchronized block.
465       * @param branch the source branch
466       * @return a finally block, or <code>null</code> if there is no
467       * enclosing try-statement
468       * @attribute inh
469       * @aspect BranchTarget
470       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:262
471       */
472      /**
473       * Find finally block of enclosing try-statement, or monitor exit
474       * block of enclosing synchronized block.
475       * @param branch the source branch
476       * @return a finally block, or <code>null</code> if there is no
477       * enclosing try-statement
478       * @attribute inh
479       * @aspect BranchTarget
480       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:262
481       */
482      @ASTNodeAnnotation.Attribute
483      public FinallyHost enclosingFinally(Stmt branch) {
484        Object _parameters = branch;
485        if (enclosingFinally_Stmt_values == null) enclosingFinally_Stmt_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
486        ASTNode$State state = state();
487        if (enclosingFinally_Stmt_values.containsKey(_parameters)) {
488          return (FinallyHost) enclosingFinally_Stmt_values.get(_parameters);
489        }
490        boolean intermediate = state.INTERMEDIATE_VALUE;
491        state.INTERMEDIATE_VALUE = false;
492        int num = state.boundariesCrossed;
493        boolean isFinal = this.is$Final();
494        FinallyHost enclosingFinally_Stmt_value = getParent().Define_enclosingFinally(this, null, branch);
495        if (isFinal && num == state().boundariesCrossed) {
496          enclosingFinally_Stmt_values.put(_parameters, enclosingFinally_Stmt_value);
497        } else {
498        }
499        state.INTERMEDIATE_VALUE |= intermediate;
500    
501        return enclosingFinally_Stmt_value;
502      }
503      /**
504       * @apilevel internal
505       */
506      protected java.util.Map enclosingFinally_Stmt_values;
507      /**
508       * @apilevel internal
509       */
510      private void enclosingFinally_Stmt_reset() {
511        enclosingFinally_Stmt_values = null;
512      }
513      /**
514       * @attribute inh
515       * @aspect DA
516       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
517       */
518      /**
519       * @attribute inh
520       * @aspect DA
521       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
522       */
523      @ASTNodeAnnotation.Attribute
524      public boolean isDAbefore(Variable v) {
525        boolean isDAbefore_Variable_value = getParent().Define_isDAbefore(this, null, v);
526    
527        return isDAbefore_Variable_value;
528      }
529      /**
530       * @attribute inh
531       * @aspect DU
532       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
533       */
534      /**
535       * @attribute inh
536       * @aspect DU
537       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
538       */
539      @ASTNodeAnnotation.Attribute
540      public boolean isDUbefore(Variable v) {
541        boolean isDUbefore_Variable_value = getParent().Define_isDUbefore(this, null, v);
542    
543        return isDUbefore_Variable_value;
544      }
545      /**
546       * @attribute inh
547       * @aspect LookupMethod
548       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46
549       */
550      /**
551       * @attribute inh
552       * @aspect LookupMethod
553       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46
554       */
555      @ASTNodeAnnotation.Attribute
556      public Collection lookupMethod(String name) {
557        Collection lookupMethod_String_value = getParent().Define_lookupMethod(this, null, name);
558    
559        return lookupMethod_String_value;
560      }
561      /**
562       * @attribute inh
563       * @aspect LookupFullyQualifiedTypes
564       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:130
565       */
566      /**
567       * @attribute inh
568       * @aspect LookupFullyQualifiedTypes
569       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:130
570       */
571      @ASTNodeAnnotation.Attribute
572      public TypeDecl lookupType(String packageName, String typeName) {
573        TypeDecl lookupType_String_String_value = getParent().Define_lookupType(this, null, packageName, typeName);
574    
575        return lookupType_String_String_value;
576      }
577      /**
578       * @attribute inh
579       * @aspect TypeScopePropagation
580       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:339
581       */
582      /**
583       * @attribute inh
584       * @aspect TypeScopePropagation
585       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:339
586       */
587      @ASTNodeAnnotation.Attribute
588      public SimpleSet lookupType(String name) {
589        SimpleSet lookupType_String_value = getParent().Define_lookupType(this, null, name);
590    
591        return lookupType_String_value;
592      }
593      /**
594       * @attribute inh
595       * @aspect VariableScope
596       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:37
597       */
598      /**
599       * @attribute inh
600       * @aspect VariableScope
601       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:37
602       */
603      @ASTNodeAnnotation.Attribute
604      public SimpleSet lookupVariable(String name) {
605        SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name);
606    
607        return lookupVariable_String_value;
608      }
609      /**
610       * @attribute inh
611       * @aspect NestedTypes
612       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:561
613       */
614      /**
615       * @attribute inh
616       * @aspect NestedTypes
617       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:561
618       */
619      @ASTNodeAnnotation.Attribute
620      public BodyDecl enclosingBodyDecl() {
621        BodyDecl enclosingBodyDecl_value = getParent().Define_enclosingBodyDecl(this, null);
622    
623        return enclosingBodyDecl_value;
624      }
625      /**
626       * @attribute inh
627       * @aspect NestedTypes
628       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:639
629       */
630      /**
631       * @attribute inh
632       * @aspect NestedTypes
633       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:639
634       */
635      @ASTNodeAnnotation.Attribute
636      public TypeDecl hostType() {
637        TypeDecl hostType_value = getParent().Define_hostType(this, null);
638    
639        return hostType_value;
640      }
641      /**
642       * @attribute inh
643       * @aspect UnreachableStatements
644       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:51
645       */
646      /**
647       * @attribute inh
648       * @aspect UnreachableStatements
649       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:51
650       */
651      @ASTNodeAnnotation.Attribute
652      public boolean reachable() {
653        boolean reachable_value = getParent().Define_reachable(this, null);
654    
655        return reachable_value;
656      }
657      /**
658       * @attribute inh
659       * @aspect UnreachableStatements
660       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:209
661       */
662      /**
663       * @attribute inh
664       * @aspect UnreachableStatements
665       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:209
666       */
667      @ASTNodeAnnotation.Attribute
668      public boolean reportUnreachable() {
669        boolean reportUnreachable_value = getParent().Define_reportUnreachable(this, null);
670    
671        return reportUnreachable_value;
672      }
673      /**
674       * Checks if the branch statement leaves the monitor.
675       * @return <code>true</code> if the branch leaves the monitor
676       * @attribute inh
677       * @aspect CreateBCode
678       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1836
679       */
680      /**
681       * Checks if the branch statement leaves the monitor.
682       * @return <code>true</code> if the branch leaves the monitor
683       * @attribute inh
684       * @aspect CreateBCode
685       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1836
686       */
687      @ASTNodeAnnotation.Attribute
688      public boolean leavesMonitor(Stmt branch, SynchronizedStmt monitor) {
689        boolean leavesMonitor_Stmt_SynchronizedStmt_value = getParent().Define_leavesMonitor(this, null, branch, monitor);
690    
691        return leavesMonitor_Stmt_SynchronizedStmt_value;
692      }
693      /**
694       * @return The next available local variable index.
695       * @attribute inh
696       * @aspect LocalNum
697       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:63
698       */
699      /**
700       * @return The next available local variable index.
701       * @attribute inh
702       * @aspect LocalNum
703       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:63
704       */
705      @ASTNodeAnnotation.Attribute
706      public int localNum() {
707        ASTNode$State state = state();
708        if (localNum_computed) {
709          return localNum_value;
710        }
711        boolean intermediate = state.INTERMEDIATE_VALUE;
712        state.INTERMEDIATE_VALUE = false;
713        int num = state.boundariesCrossed;
714        boolean isFinal = this.is$Final();
715        localNum_value = getParent().Define_localNum(this, null);
716        if (isFinal && num == state().boundariesCrossed) {
717          localNum_computed = true;
718        } else {
719        }
720        state.INTERMEDIATE_VALUE |= intermediate;
721    
722        return localNum_value;
723      }
724      /**
725       * @apilevel internal
726       */
727      protected boolean localNum_computed = false;
728      /**
729       * @apilevel internal
730       */
731      protected int localNum_value;
732      /**
733       * @apilevel internal
734       */
735      private void localNum_reset() {
736        localNum_computed = false;
737      }
738      /**
739       * @apilevel internal
740       */
741      public ASTNode rewriteTo() {
742        return super.rewriteTo();
743      }
744    }