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:209
027     * @production ContinueStmt : {@link Stmt} ::= <span class="component">&lt;Label:String&gt;</span> <span class="component">[Finally:{@link Block}]</span>;
028    
029     */
030    public class ContinueStmt extends Stmt implements Cloneable {
031      /**
032       * @aspect BranchTarget
033       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:96
034       */
035      public void collectBranches(Collection<Stmt> c) {
036        c.add(this);
037      }
038      /**
039       * @aspect NameCheck
040       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:465
041       */
042      public void nameCheck() {
043        if (!insideLoop()) {
044          error("continue outside loop");
045        } else if (hasLabel()) {
046          LabeledStmt label = lookupLabel(getLabel());
047          if (label == null) {
048            error("labeled continue must have visible matching label");
049          } else if (!label.getStmt().continueLabel()) {
050            errorf("%s is not a loop label", getLabel());
051          }
052        }
053      }
054      /**
055       * @aspect Java4PrettyPrint
056       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:194
057       */
058      public void prettyPrint(PrettyPrinter out) {
059        out.print("continue");
060        if (hasLabel()) {
061          out.print(" ");
062          out.print(getLabel());
063        }
064        out.print(";");
065      }
066      /**
067       * @aspect CreateBCode
068       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1656
069       */
070      public void createBCode(CodeGeneration gen) {
071        super.createBCode(gen);
072        if (hasFinally()) {
073          int nextRange = gen.constantPool().newLabel();
074          getFinally().createBCode(gen);
075          gen.emitGoto(targetStmt().continue_label());
076          gen.addLabel(nextRange);
077          gen.monitorRangesStart(this, nextRange);
078        } else {
079          gen.emitGoto(targetStmt().continue_label());
080        }
081      }
082      /**
083       * @declaredat ASTNode:1
084       */
085      public ContinueStmt() {
086        super();
087      }
088      /**
089       * Initializes the child array to the correct size.
090       * Initializes List and Opt nta children.
091       * @apilevel internal
092       * @ast method
093       * @declaredat ASTNode:10
094       */
095      public void init$Children() {
096        children = new ASTNode[1];
097        setChild(new Opt(), 0);
098      }
099      /**
100       * @declaredat ASTNode:14
101       */
102      public ContinueStmt(String p0) {
103        setLabel(p0);
104      }
105      /**
106       * @declaredat ASTNode:17
107       */
108      public ContinueStmt(beaver.Symbol p0) {
109        setLabel(p0);
110      }
111      /**
112       * @apilevel low-level
113       * @declaredat ASTNode:23
114       */
115      protected int numChildren() {
116        return 0;
117      }
118      /**
119       * @apilevel internal
120       * @declaredat ASTNode:29
121       */
122      public boolean mayHaveRewrite() {
123        return false;
124      }
125      /**
126       * @apilevel internal
127       * @declaredat ASTNode:35
128       */
129      public void flushAttrCache() {
130        super.flushAttrCache();
131        targetStmt_reset();
132        isDAafter_Variable_reset();
133        isDUafterReachedFinallyBlocks_Variable_reset();
134        isDAafterReachedFinallyBlocks_Variable_reset();
135        isDUafter_Variable_reset();
136        getFinallyOpt_reset();
137        canCompleteNormally_reset();
138        lookupLabel_String_reset();
139      }
140      /**
141       * @apilevel internal
142       * @declaredat ASTNode:49
143       */
144      public void flushCollectionCache() {
145        super.flushCollectionCache();
146      }
147      /**
148       * @apilevel internal
149       * @declaredat ASTNode:55
150       */
151      public void flushRewriteCache() {
152        super.flushRewriteCache();
153      }
154      /**
155       * @apilevel internal
156       * @declaredat ASTNode:61
157       */
158      public ContinueStmt clone() throws CloneNotSupportedException {
159        ContinueStmt node = (ContinueStmt) super.clone();
160        return node;
161      }
162      /**
163       * @apilevel internal
164       * @declaredat ASTNode:68
165       */
166      public ContinueStmt copy() {
167        try {
168          ContinueStmt node = (ContinueStmt) clone();
169          node.parent = null;
170          if (children != null) {
171            node.children = (ASTNode[]) children.clone();
172          }
173          return node;
174        } catch (CloneNotSupportedException e) {
175          throw new Error("Error: clone not supported for " + getClass().getName());
176        }
177      }
178      /**
179       * Create a deep copy of the AST subtree at this node.
180       * The copy is dangling, i.e. has no parent.
181       * @return dangling copy of the subtree at this node
182       * @apilevel low-level
183       * @deprecated Please use treeCopy or treeCopyNoTransform instead
184       * @declaredat ASTNode:87
185       */
186      @Deprecated
187      public ContinueStmt fullCopy() {
188        return treeCopyNoTransform();
189      }
190      /**
191       * Create a deep copy of the AST subtree at this node.
192       * The copy is dangling, i.e. has no parent.
193       * @return dangling copy of the subtree at this node
194       * @apilevel low-level
195       * @declaredat ASTNode:97
196       */
197      public ContinueStmt treeCopyNoTransform() {
198        ContinueStmt tree = (ContinueStmt) copy();
199        if (children != null) {
200          for (int i = 0; i < children.length; ++i) {
201            switch (i) {
202            case 0:
203              tree.children[i] = new Opt();
204              continue;
205            }
206            ASTNode child = (ASTNode) children[i];
207            if (child != null) {
208              child = child.treeCopyNoTransform();
209              tree.setChild(child, i);
210            }
211          }
212        }
213        return tree;
214      }
215      /**
216       * Create a deep copy of the AST subtree at this node.
217       * The subtree of this node is traversed to trigger rewrites before copy.
218       * The copy is dangling, i.e. has no parent.
219       * @return dangling copy of the subtree at this node
220       * @apilevel low-level
221       * @declaredat ASTNode:122
222       */
223      public ContinueStmt treeCopy() {
224        doFullTraversal();
225        return treeCopyNoTransform();
226      }
227      /**
228       * @apilevel internal
229       * @declaredat ASTNode:129
230       */
231      protected boolean is$Equal(ASTNode node) {
232        return super.is$Equal(node) && (tokenString_Label == ((ContinueStmt)node).tokenString_Label);    
233      }
234      /**
235       * Replaces the lexeme Label.
236       * @param value The new value for the lexeme Label.
237       * @apilevel high-level
238       */
239      public void setLabel(String value) {
240        tokenString_Label = value;
241      }
242      /**
243       * @apilevel internal
244       */
245      protected String tokenString_Label;
246      /**
247       */
248      public int Labelstart;
249      /**
250       */
251      public int Labelend;
252      /**
253       * JastAdd-internal setter for lexeme Label using the Beaver parser.
254       * @param symbol Symbol containing the new value for the lexeme Label
255       * @apilevel internal
256       */
257      public void setLabel(beaver.Symbol symbol) {
258        if (symbol.value != null && !(symbol.value instanceof String))
259        throw new UnsupportedOperationException("setLabel is only valid for String lexemes");
260        tokenString_Label = (String)symbol.value;
261        Labelstart = symbol.getStart();
262        Labelend = symbol.getEnd();
263      }
264      /**
265       * Retrieves the value for the lexeme Label.
266       * @return The value for the lexeme Label.
267       * @apilevel high-level
268       */
269      @ASTNodeAnnotation.Token(name="Label")
270      public String getLabel() {
271        return tokenString_Label != null ? tokenString_Label : "";
272      }
273      /**
274       * Replaces the (optional) Finally child.
275       * @param node The new node to be used as the Finally child.
276       * @apilevel high-level
277       */
278      public void setFinally(Block node) {
279        getFinallyOpt().setChild(node, 0);
280      }
281      /**
282       * Check whether the optional Finally child exists.
283       * @return {@code true} if the optional Finally child exists, {@code false} if it does not.
284       * @apilevel high-level
285       */
286      public boolean hasFinally() {
287        return getFinallyOpt().getNumChild() != 0;
288      }
289      /**
290       * Retrieves the (optional) Finally child.
291       * @return The Finally child, if it exists. Returns {@code null} otherwise.
292       * @apilevel low-level
293       */
294      public Block getFinally() {
295        return (Block) getFinallyOpt().getChild(0);
296      }
297      /**
298       * Retrieves the optional node for child Finally. This is the <code>Opt</code> node containing the child Finally, not the actual child!
299       * <p><em>This method does not invoke AST transformations.</em></p>
300       * @return The optional node for child Finally.
301       * @apilevel low-level
302       */
303      public Opt<Block> getFinallyOptNoTransform() {
304        return (Opt<Block>) getChildNoTransform(0);
305      }
306      /**
307       * Retrieves the child position of the optional child Finally.
308       * @return The the child position of the optional child Finally.
309       * @apilevel low-level
310       */
311      protected int getFinallyOptChildPosition() {
312        return 0;
313      }
314      /**
315       * @attribute syn
316       * @aspect BranchTarget
317       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:116
318       */
319      @ASTNodeAnnotation.Attribute
320      public boolean hasLabel() {
321        boolean hasLabel_value = !getLabel().equals("");
322    
323        return hasLabel_value;
324      }
325      /**
326       * @return <code>true</code> if this statement can branch to
327       * the target statement.
328       * @attribute syn
329       * @aspect BranchTarget
330       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:187
331       */
332      @ASTNodeAnnotation.Attribute
333      public boolean canBranchTo(BranchTargetStmt target) {
334        boolean canBranchTo_BranchTargetStmt_value = !hasLabel();
335    
336        return canBranchTo_BranchTargetStmt_value;
337      }
338      /**
339       * @attribute syn
340       * @aspect BranchTarget
341       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:188
342       */
343      @ASTNodeAnnotation.Attribute
344      public boolean canBranchTo(LabeledStmt target) {
345        boolean canBranchTo_LabeledStmt_value = hasLabel() && target.getLabel().equals(getLabel());
346    
347        return canBranchTo_LabeledStmt_value;
348      }
349      /**
350       * @attribute syn
351       * @aspect BranchTarget
352       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:189
353       */
354      @ASTNodeAnnotation.Attribute
355      public boolean canBranchTo(SwitchStmt target) {
356        boolean canBranchTo_SwitchStmt_value = false;
357    
358        return canBranchTo_SwitchStmt_value;
359      }
360      /**
361       * @apilevel internal
362       */
363      protected boolean targetStmt_computed = false;
364      /**
365       * @apilevel internal
366       */
367      protected Stmt targetStmt_value;
368      /**
369       * @apilevel internal
370       */
371      private void targetStmt_reset() {
372        targetStmt_computed = false;
373        targetStmt_value = null;
374      }
375      /**
376       * Find the target statement for break and continue. This can be a try
377       * statement with a finally block that can not complete normally.
378       * @attribute syn
379       * @aspect BranchTarget
380       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:46
381       */
382      @ASTNodeAnnotation.Attribute
383      public Stmt targetStmt() {
384        ASTNode$State state = state();
385        if (targetStmt_computed) {
386          return targetStmt_value;
387        }
388        boolean intermediate = state.INTERMEDIATE_VALUE;
389        state.INTERMEDIATE_VALUE = false;
390        int num = state.boundariesCrossed;
391        boolean isFinal = this.is$Final();
392        targetStmt_value = branchTarget(this);
393        if (isFinal && num == state().boundariesCrossed) {
394          targetStmt_computed = true;
395        } else {
396        }
397        state.INTERMEDIATE_VALUE |= intermediate;
398    
399        return targetStmt_value;
400      }
401      /**
402       * @apilevel internal
403       */
404      protected java.util.Map isDAafter_Variable_values;
405      /**
406       * @apilevel internal
407       */
408      private void isDAafter_Variable_reset() {
409        isDAafter_Variable_values = null;
410      }
411      /**
412       * @attribute syn
413       * @aspect DA
414       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257
415       */
416      @ASTNodeAnnotation.Attribute
417      public boolean isDAafter(Variable v) {
418        Object _parameters = v;
419        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
420        ASTNode$State state = state();
421        if (isDAafter_Variable_values.containsKey(_parameters)) {
422          return (Boolean) isDAafter_Variable_values.get(_parameters);
423        }
424        boolean intermediate = state.INTERMEDIATE_VALUE;
425        state.INTERMEDIATE_VALUE = false;
426        int num = state.boundariesCrossed;
427        boolean isFinal = this.is$Final();
428        boolean isDAafter_Variable_value = true;
429        if (isFinal && num == state().boundariesCrossed) {
430          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
431        } else {
432        }
433        state.INTERMEDIATE_VALUE |= intermediate;
434    
435        return isDAafter_Variable_value;
436      }
437      /**
438       * @apilevel internal
439       */
440      protected java.util.Map isDUafterReachedFinallyBlocks_Variable_values;
441      /**
442       * @apilevel internal
443       */
444      private void isDUafterReachedFinallyBlocks_Variable_reset() {
445        isDUafterReachedFinallyBlocks_Variable_values = null;
446      }
447      /**
448       * @attribute syn
449       * @aspect DU
450       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1071
451       */
452      @ASTNodeAnnotation.Attribute
453      public boolean isDUafterReachedFinallyBlocks(Variable v) {
454        Object _parameters = v;
455        if (isDUafterReachedFinallyBlocks_Variable_values == null) isDUafterReachedFinallyBlocks_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
456        ASTNode$State state = state();
457        if (isDUafterReachedFinallyBlocks_Variable_values.containsKey(_parameters)) {
458          return (Boolean) isDUafterReachedFinallyBlocks_Variable_values.get(_parameters);
459        }
460        boolean intermediate = state.INTERMEDIATE_VALUE;
461        state.INTERMEDIATE_VALUE = false;
462        int num = state.boundariesCrossed;
463        boolean isFinal = this.is$Final();
464        boolean isDUafterReachedFinallyBlocks_Variable_value = isDUafterReachedFinallyBlocks_compute(v);
465        if (isFinal && num == state().boundariesCrossed) {
466          isDUafterReachedFinallyBlocks_Variable_values.put(_parameters, isDUafterReachedFinallyBlocks_Variable_value);
467        } else {
468        }
469        state.INTERMEDIATE_VALUE |= intermediate;
470    
471        return isDUafterReachedFinallyBlocks_Variable_value;
472      }
473      /**
474       * @apilevel internal
475       */
476      private boolean isDUafterReachedFinallyBlocks_compute(Variable v) {
477          Iterator<FinallyHost> iter = finallyIterator();
478          if (!isDUbefore(v) && !iter.hasNext()) {
479            return false;
480          }
481          while (iter.hasNext()) {
482            FinallyHost f = iter.next();
483            if (!f.isDUafterFinally(v)) {
484              return false;
485            }
486          }
487          return true;
488        }
489      /**
490       * @apilevel internal
491       */
492      protected java.util.Map isDAafterReachedFinallyBlocks_Variable_values;
493      /**
494       * @apilevel internal
495       */
496      private void isDAafterReachedFinallyBlocks_Variable_reset() {
497        isDAafterReachedFinallyBlocks_Variable_values = null;
498      }
499      /**
500       * @attribute syn
501       * @aspect DU
502       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1115
503       */
504      @ASTNodeAnnotation.Attribute
505      public boolean isDAafterReachedFinallyBlocks(Variable v) {
506        Object _parameters = v;
507        if (isDAafterReachedFinallyBlocks_Variable_values == null) isDAafterReachedFinallyBlocks_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
508        ASTNode$State state = state();
509        if (isDAafterReachedFinallyBlocks_Variable_values.containsKey(_parameters)) {
510          return (Boolean) isDAafterReachedFinallyBlocks_Variable_values.get(_parameters);
511        }
512        boolean intermediate = state.INTERMEDIATE_VALUE;
513        state.INTERMEDIATE_VALUE = false;
514        int num = state.boundariesCrossed;
515        boolean isFinal = this.is$Final();
516        boolean isDAafterReachedFinallyBlocks_Variable_value = isDAafterReachedFinallyBlocks_compute(v);
517        if (isFinal && num == state().boundariesCrossed) {
518          isDAafterReachedFinallyBlocks_Variable_values.put(_parameters, isDAafterReachedFinallyBlocks_Variable_value);
519        } else {
520        }
521        state.INTERMEDIATE_VALUE |= intermediate;
522    
523        return isDAafterReachedFinallyBlocks_Variable_value;
524      }
525      /**
526       * @apilevel internal
527       */
528      private boolean isDAafterReachedFinallyBlocks_compute(Variable v) {
529          if (isDAbefore(v)) {
530            return true;
531          }
532          Iterator<FinallyHost> iter = finallyIterator();
533          if (!iter.hasNext()) {
534            return false;
535          }
536          while (iter.hasNext()) {
537            FinallyHost f = iter.next();
538            if (!f.isDAafterFinally(v)) {
539              return false;
540            }
541          }
542          return true;
543        }
544      /**
545       * @apilevel internal
546       */
547      protected java.util.Map isDUafter_Variable_values;
548      /**
549       * @apilevel internal
550       */
551      private void isDUafter_Variable_reset() {
552        isDUafter_Variable_values = null;
553      }
554      /**
555       * @attribute syn
556       * @aspect DU
557       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781
558       */
559      @ASTNodeAnnotation.Attribute
560      public boolean isDUafter(Variable v) {
561        Object _parameters = v;
562        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
563        ASTNode$State state = state();
564        if (isDUafter_Variable_values.containsKey(_parameters)) {
565          return (Boolean) isDUafter_Variable_values.get(_parameters);
566        }
567        boolean intermediate = state.INTERMEDIATE_VALUE;
568        state.INTERMEDIATE_VALUE = false;
569        int num = state.boundariesCrossed;
570        boolean isFinal = this.is$Final();
571        boolean isDUafter_Variable_value = true;
572        if (isFinal && num == state().boundariesCrossed) {
573          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
574        } else {
575        }
576        state.INTERMEDIATE_VALUE |= intermediate;
577    
578        return isDUafter_Variable_value;
579      }
580      /**
581       * @apilevel internal
582       */
583      protected boolean getFinallyOpt_computed = false;
584      /**
585       * @apilevel internal
586       */
587      protected Opt<Block> getFinallyOpt_value;
588      /**
589       * @apilevel internal
590       */
591      private void getFinallyOpt_reset() {
592        getFinallyOpt_computed = false;
593        getFinallyOpt_value = null;
594      }
595      /**
596       * @attribute syn nta
597       * @aspect NTAFinally
598       * @declaredat /home/jesper/git/extendj/java4/frontend/NTAFinally.jrag:57
599       */
600      @ASTNodeAnnotation.Attribute
601      public Opt<Block> getFinallyOpt() {
602        ASTNode$State state = state();
603        if (getFinallyOpt_computed) {
604          return (Opt<Block>) getChild(getFinallyOptChildPosition());
605        }
606        boolean intermediate = state.INTERMEDIATE_VALUE;
607        state.INTERMEDIATE_VALUE = false;
608        int num = state.boundariesCrossed;
609        boolean isFinal = this.is$Final();
610        getFinallyOpt_value = getFinallyOpt_compute();
611        setChild(getFinallyOpt_value, getFinallyOptChildPosition());
612        if (isFinal && num == state().boundariesCrossed) {
613          getFinallyOpt_computed = true;
614        } else {
615        }
616        state.INTERMEDIATE_VALUE |= intermediate;
617    
618        Opt<Block> node = (Opt<Block>) this.getChild(getFinallyOptChildPosition());
619        return node;
620      }
621      /**
622       * @apilevel internal
623       */
624      private Opt<Block> getFinallyOpt_compute() {
625          return branchFinallyOpt();
626        }
627      /**
628       * @apilevel internal
629       */
630      protected boolean canCompleteNormally_computed = false;
631      /**
632       * @apilevel internal
633       */
634      protected boolean canCompleteNormally_value;
635      /**
636       * @apilevel internal
637       */
638      private void canCompleteNormally_reset() {
639        canCompleteNormally_computed = false;
640      }
641      /**
642       * @attribute syn
643       * @aspect UnreachableStatements
644       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53
645       */
646      @ASTNodeAnnotation.Attribute
647      public boolean canCompleteNormally() {
648        ASTNode$State state = state();
649        if (canCompleteNormally_computed) {
650          return canCompleteNormally_value;
651        }
652        boolean intermediate = state.INTERMEDIATE_VALUE;
653        state.INTERMEDIATE_VALUE = false;
654        int num = state.boundariesCrossed;
655        boolean isFinal = this.is$Final();
656        canCompleteNormally_value = false;
657        if (isFinal && num == state().boundariesCrossed) {
658          canCompleteNormally_computed = true;
659        } else {
660        }
661        state.INTERMEDIATE_VALUE |= intermediate;
662    
663        return canCompleteNormally_value;
664      }
665      /**
666       * @attribute syn
667       * @aspect PreciseRethrow
668       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84
669       */
670      @ASTNodeAnnotation.Attribute
671      public boolean modifiedInScope(Variable var) {
672        boolean modifiedInScope_Variable_value = false;
673    
674        return modifiedInScope_Variable_value;
675      }
676      /**
677       * @attribute inh
678       * @aspect BranchTarget
679       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:250
680       */
681      /**
682       * @attribute inh
683       * @aspect BranchTarget
684       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:250
685       */
686      @ASTNodeAnnotation.Attribute
687      public LabeledStmt lookupLabel(String name) {
688        Object _parameters = name;
689        if (lookupLabel_String_values == null) lookupLabel_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
690        ASTNode$State state = state();
691        if (lookupLabel_String_values.containsKey(_parameters)) {
692          return (LabeledStmt) lookupLabel_String_values.get(_parameters);
693        }
694        boolean intermediate = state.INTERMEDIATE_VALUE;
695        state.INTERMEDIATE_VALUE = false;
696        int num = state.boundariesCrossed;
697        boolean isFinal = this.is$Final();
698        LabeledStmt lookupLabel_String_value = getParent().Define_lookupLabel(this, null, name);
699        if (isFinal && num == state().boundariesCrossed) {
700          lookupLabel_String_values.put(_parameters, lookupLabel_String_value);
701        } else {
702        }
703        state.INTERMEDIATE_VALUE |= intermediate;
704    
705        return lookupLabel_String_value;
706      }
707      /**
708       * @apilevel internal
709       */
710      protected java.util.Map lookupLabel_String_values;
711      /**
712       * @apilevel internal
713       */
714      private void lookupLabel_String_reset() {
715        lookupLabel_String_values = null;
716      }
717      /**
718       * @attribute inh
719       * @aspect NameCheck
720       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:441
721       */
722      /**
723       * @attribute inh
724       * @aspect NameCheck
725       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:441
726       */
727      @ASTNodeAnnotation.Attribute
728      public boolean insideLoop() {
729        boolean insideLoop_value = getParent().Define_insideLoop(this, null);
730    
731        return insideLoop_value;
732      }
733      /**
734       * @apilevel internal
735       */
736      public ASTNode rewriteTo() {
737        return super.rewriteTo();
738      }
739    }