001    /* This file was generated with JastAdd2 (http://jastadd.org) version R20130213 */
002    package AST;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.*;
007    import beaver.*;
008    import java.util.ArrayList;
009    import java.util.zip.*;
010    import java.io.*;
011    import java.io.FileNotFoundException;
012    import java.util.Collection;
013    /**
014     * @production DoStmt : {@link BranchTargetStmt} ::= <span class="component">{@link Stmt}</span> <span class="component">Condition:{@link Expr}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:209
017     */
018    public class DoStmt extends BranchTargetStmt implements Cloneable {
019      /**
020       * @apilevel low-level
021       */
022      public void flushCache() {
023      }
024      /**
025       * @apilevel internal
026       */
027      public void flushCollectionCache() {
028      }
029      /**
030       * @apilevel internal
031       */
032      @SuppressWarnings({"unchecked", "cast"})
033      public DoStmt clone() throws CloneNotSupportedException {
034        DoStmt node = (DoStmt)super.clone();
035        node.targetOf_ContinueStmt_values = null;
036        node.targetOf_BreakStmt_values = null;
037        node.isDAafter_Variable_values = null;
038        node.isDUafter_Variable_values = null;
039        node.isDUbeforeCondition_Variable_values = null;
040        node.canCompleteNormally_computed = false;
041        node.begin_label_computed = false;
042        node.cond_label_computed = false;
043        node.end_label_computed = false;
044        node.in$Circle(false);
045        node.is$Final(false);
046        return node;
047      }
048    /**
049     * @apilevel internal
050     */
051      @SuppressWarnings({"unchecked", "cast"})
052    public DoStmt copy() {
053      
054      try {
055        DoStmt node = (DoStmt) clone();
056        node.parent = null;
057        if(children != null)
058          node.children = (ASTNode[]) children.clone();
059        
060        return node;
061      } catch (CloneNotSupportedException e) {
062        throw new Error("Error: clone not supported for " + getClass().getName());
063      }
064      
065    }/**
066     * Create a deep copy of the AST subtree at this node.
067     * The copy is dangling, i.e. has no parent.
068     * @return dangling copy of the subtree at this node
069     * @apilevel low-level
070     */
071      @SuppressWarnings({"unchecked", "cast"})
072    public DoStmt fullCopy() {
073      
074      DoStmt tree = (DoStmt) copy();
075      if (children != null) {
076        for (int i = 0; i < children.length; ++i) {
077          
078          ASTNode child = (ASTNode) children[i];
079          if(child != null) {
080            child = child.fullCopy();
081            tree.setChild(child, i);
082          }
083        }
084      }
085      return tree;
086      
087    }  /**
088       * @ast method 
089       * @aspect PrettyPrint
090       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:595
091       */
092      public void toString(StringBuffer s) {
093        s.append(indent());
094        s.append("do ");
095        getStmt().toString(s);
096        s.append("while(");
097        getCondition().toString(s);
098        s.append(");");
099      }
100      /**
101       * @ast method 
102       * @aspect TypeCheck
103       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:328
104       */
105      public void typeCheck() {
106        TypeDecl cond = getCondition().type();
107        if(!cond.isBoolean()) {
108          error("the type of \"" + getCondition() + "\" is " + cond.name() + " which is not boolean");
109        }
110      }
111      /**
112       * @ast method 
113       * @aspect CreateBCode
114       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1363
115       */
116      public void createBCode(CodeGeneration gen) {
117        super.createBCode(gen);
118        gen.addLabel(begin_label());
119        getStmt().createBCode(gen);
120        gen.addLabel(cond_label());
121        getCondition().emitEvalBranch(gen);
122        gen.addLabel(end_label());
123      }
124      /**
125       * @ast method 
126       * 
127       */
128      public DoStmt() {
129        super();
130    
131    
132      }
133      /**
134       * Initializes the child array to the correct size.
135       * Initializes List and Opt nta children.
136       * @apilevel internal
137       * @ast method
138       * @ast method 
139       * 
140       */
141      public void init$Children() {
142        children = new ASTNode[2];
143      }
144      /**
145       * @ast method 
146       * 
147       */
148      public DoStmt(Stmt p0, Expr p1) {
149        setChild(p0, 0);
150        setChild(p1, 1);
151      }
152      /**
153       * @apilevel low-level
154       * @ast method 
155       * 
156       */
157      protected int numChildren() {
158        return 2;
159      }
160      /**
161       * @apilevel internal
162       * @ast method 
163       * 
164       */
165      public boolean mayHaveRewrite() {
166        return false;
167      }
168      /**
169       * Replaces the Stmt child.
170       * @param node The new node to replace the Stmt child.
171       * @apilevel high-level
172       * @ast method 
173       * 
174       */
175      public void setStmt(Stmt node) {
176        setChild(node, 0);
177      }
178      /**
179       * Retrieves the Stmt child.
180       * @return The current node used as the Stmt child.
181       * @apilevel high-level
182       * @ast method 
183       * 
184       */
185      public Stmt getStmt() {
186        return (Stmt)getChild(0);
187      }
188      /**
189       * Retrieves the Stmt child.
190       * <p><em>This method does not invoke AST transformations.</em></p>
191       * @return The current node used as the Stmt child.
192       * @apilevel low-level
193       * @ast method 
194       * 
195       */
196      public Stmt getStmtNoTransform() {
197        return (Stmt)getChildNoTransform(0);
198      }
199      /**
200       * Replaces the Condition child.
201       * @param node The new node to replace the Condition child.
202       * @apilevel high-level
203       * @ast method 
204       * 
205       */
206      public void setCondition(Expr node) {
207        setChild(node, 1);
208      }
209      /**
210       * Retrieves the Condition child.
211       * @return The current node used as the Condition child.
212       * @apilevel high-level
213       * @ast method 
214       * 
215       */
216      public Expr getCondition() {
217        return (Expr)getChild(1);
218      }
219      /**
220       * Retrieves the Condition child.
221       * <p><em>This method does not invoke AST transformations.</em></p>
222       * @return The current node used as the Condition child.
223       * @apilevel low-level
224       * @ast method 
225       * 
226       */
227      public Expr getConditionNoTransform() {
228        return (Expr)getChildNoTransform(1);
229      }
230      protected java.util.Map targetOf_ContinueStmt_values;
231      /**
232       * @attribute syn
233       * @aspect BranchTarget
234       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:70
235       */
236      @SuppressWarnings({"unchecked", "cast"})
237      public boolean targetOf(ContinueStmt stmt) {
238        Object _parameters = stmt;
239        if(targetOf_ContinueStmt_values == null) targetOf_ContinueStmt_values = new java.util.HashMap(4);
240        if(targetOf_ContinueStmt_values.containsKey(_parameters)) {
241          return ((Boolean)targetOf_ContinueStmt_values.get(_parameters)).booleanValue();
242        }
243          ASTNode$State state = state();
244      int num = state.boundariesCrossed;
245      boolean isFinal = this.is$Final();
246        boolean targetOf_ContinueStmt_value = targetOf_compute(stmt);
247      if(isFinal && num == state().boundariesCrossed){ targetOf_ContinueStmt_values.put(_parameters, Boolean.valueOf(targetOf_ContinueStmt_value)); }
248            return targetOf_ContinueStmt_value;
249      }
250      /**
251       * @apilevel internal
252       */
253      private boolean targetOf_compute(ContinueStmt stmt) {  return !stmt.hasLabel();  }
254      protected java.util.Map targetOf_BreakStmt_values;
255      /**
256       * @attribute syn
257       * @aspect BranchTarget
258       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:78
259       */
260      @SuppressWarnings({"unchecked", "cast"})
261      public boolean targetOf(BreakStmt stmt) {
262        Object _parameters = stmt;
263        if(targetOf_BreakStmt_values == null) targetOf_BreakStmt_values = new java.util.HashMap(4);
264        if(targetOf_BreakStmt_values.containsKey(_parameters)) {
265          return ((Boolean)targetOf_BreakStmt_values.get(_parameters)).booleanValue();
266        }
267          ASTNode$State state = state();
268      int num = state.boundariesCrossed;
269      boolean isFinal = this.is$Final();
270        boolean targetOf_BreakStmt_value = targetOf_compute(stmt);
271      if(isFinal && num == state().boundariesCrossed){ targetOf_BreakStmt_values.put(_parameters, Boolean.valueOf(targetOf_BreakStmt_value)); }
272            return targetOf_BreakStmt_value;
273      }
274      /**
275       * @apilevel internal
276       */
277      private boolean targetOf_compute(BreakStmt stmt) {  return !stmt.hasLabel();  }
278      protected java.util.Map isDAafter_Variable_values;
279      /**
280       * @attribute syn
281       * @aspect DA
282       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:589
283       */
284      @SuppressWarnings({"unchecked", "cast"})
285      public boolean isDAafter(Variable v) {
286        Object _parameters = v;
287        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
288        if(isDAafter_Variable_values.containsKey(_parameters)) {
289          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
290        }
291          ASTNode$State state = state();
292      int num = state.boundariesCrossed;
293      boolean isFinal = this.is$Final();
294        boolean isDAafter_Variable_value = isDAafter_compute(v);
295      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
296            return isDAafter_Variable_value;
297      }
298      /**
299       * @apilevel internal
300       */
301      private boolean isDAafter_compute(Variable v) {
302        if(!getCondition().isDAafterFalse(v))
303          return false;
304        for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
305          BreakStmt stmt = (BreakStmt)iter.next();
306          if(!stmt.isDAafterReachedFinallyBlocks(v))
307            return false;
308        }
309        return true;
310      }
311      protected java.util.Map isDUafter_Variable_values;
312      /**
313       * @attribute syn
314       * @aspect DU
315       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1068
316       */
317      @SuppressWarnings({"unchecked", "cast"})
318      public boolean isDUafter(Variable v) {
319        Object _parameters = v;
320        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
321        if(isDUafter_Variable_values.containsKey(_parameters)) {
322          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
323        }
324          ASTNode$State state = state();
325      int num = state.boundariesCrossed;
326      boolean isFinal = this.is$Final();
327        boolean isDUafter_Variable_value = isDUafter_compute(v);
328      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
329            return isDUafter_Variable_value;
330      }
331      /**
332       * @apilevel internal
333       */
334      private boolean isDUafter_compute(Variable v) {
335        if(!isDUbeforeCondition(v)) // start a circular evaluation here
336          return false;
337        if(!getCondition().isDUafterFalse(v))
338          return false;
339        for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
340          BreakStmt stmt = (BreakStmt)iter.next();
341          if(!stmt.isDUafterReachedFinallyBlocks(v))
342            return false;
343        }
344        return true;
345      }
346      protected java.util.Map isDUbeforeCondition_Variable_values;
347      /**
348       * @attribute syn
349       * @aspect DU
350       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1082
351       */
352      @SuppressWarnings({"unchecked", "cast"})
353      public boolean isDUbeforeCondition(Variable v) {
354        Object _parameters = v;
355        if(isDUbeforeCondition_Variable_values == null) isDUbeforeCondition_Variable_values = new java.util.HashMap(4);
356        ASTNode$State.CircularValue _value;
357        if(isDUbeforeCondition_Variable_values.containsKey(_parameters)) {
358          Object _o = isDUbeforeCondition_Variable_values.get(_parameters);
359          if(!(_o instanceof ASTNode$State.CircularValue)) {
360            return ((Boolean)_o).booleanValue();
361          }
362          else
363            _value = (ASTNode$State.CircularValue)_o;
364        }
365        else {
366          _value = new ASTNode$State.CircularValue();
367          isDUbeforeCondition_Variable_values.put(_parameters, _value);
368          _value.value = Boolean.valueOf(true);
369        }
370        ASTNode$State state = state();
371        if (!state.IN_CIRCLE) {
372          state.IN_CIRCLE = true;
373          int num = state.boundariesCrossed;
374          boolean isFinal = this.is$Final();
375          boolean new_isDUbeforeCondition_Variable_value;
376          do {
377            _value.visited = new Integer(state.CIRCLE_INDEX);
378            state.CHANGE = false;
379            new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v);
380            if (new_isDUbeforeCondition_Variable_value!=((Boolean)_value.value).booleanValue()) {
381              state.CHANGE = true;
382              _value.value = Boolean.valueOf(new_isDUbeforeCondition_Variable_value);
383            }
384            state.CIRCLE_INDEX++;
385          } while (state.CHANGE);
386            if(isFinal && num == state().boundariesCrossed) {
387            isDUbeforeCondition_Variable_values.put(_parameters, new_isDUbeforeCondition_Variable_value);
388          }
389          else {
390            isDUbeforeCondition_Variable_values.remove(_parameters);
391          state.RESET_CYCLE = true;
392          isDUbeforeCondition_compute(v);
393          state.RESET_CYCLE = false;
394          }
395          state.IN_CIRCLE = false; 
396          return new_isDUbeforeCondition_Variable_value;
397        }
398        if(!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
399          _value.visited = new Integer(state.CIRCLE_INDEX);
400          boolean new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v);
401          if (state.RESET_CYCLE) {
402            isDUbeforeCondition_Variable_values.remove(_parameters);
403          }
404          else if (new_isDUbeforeCondition_Variable_value!=((Boolean)_value.value).booleanValue()) {
405            state.CHANGE = true;
406            _value.value = new_isDUbeforeCondition_Variable_value;
407          }
408          return new_isDUbeforeCondition_Variable_value;
409        }
410        return ((Boolean)_value.value).booleanValue();
411      }
412      /**
413       * @apilevel internal
414       */
415      private boolean isDUbeforeCondition_compute(Variable v) {
416        if(!getStmt().isDUafter(v))
417          return false;
418        else {
419          for(Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
420            ContinueStmt stmt = (ContinueStmt)iter.next();
421            if(!stmt.isDUafterReachedFinallyBlocks(v))
422              return false;
423          }
424        }
425        return true;
426      }
427      /**
428       * @attribute syn
429       * @aspect NameCheck
430       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:401
431       */
432      public boolean continueLabel() {
433        ASTNode$State state = state();
434        try {  return true;  }
435        finally {
436        }
437      }
438      /**
439       * @apilevel internal
440       */
441      protected boolean canCompleteNormally_computed = false;
442      /**
443       * @apilevel internal
444       */
445      protected boolean canCompleteNormally_value;
446      /**
447       * @attribute syn
448       * @aspect UnreachableStatements
449       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:88
450       */
451      @SuppressWarnings({"unchecked", "cast"})
452      public boolean canCompleteNormally() {
453        if(canCompleteNormally_computed) {
454          return canCompleteNormally_value;
455        }
456          ASTNode$State state = state();
457      int num = state.boundariesCrossed;
458      boolean isFinal = this.is$Final();
459        canCompleteNormally_value = canCompleteNormally_compute();
460      if(isFinal && num == state().boundariesCrossed){ canCompleteNormally_computed = true; }
461            return canCompleteNormally_value;
462      }
463      /**
464       * @apilevel internal
465       */
466      private boolean canCompleteNormally_compute() {  return getStmt().canCompleteNormally() && (!getCondition().isConstant() || !getCondition().isTrue())
467        || reachableContinue() && (!getCondition().isConstant() || !getCondition().isTrue()) || reachableBreak();  }
468      /**
469       * @attribute syn
470       * @aspect CreateBCode
471       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:946
472       */
473      public boolean definesLabel() {
474        ASTNode$State state = state();
475        try {  return true;  }
476        finally {
477        }
478      }
479      /**
480       * @apilevel internal
481       */
482      protected boolean begin_label_computed = false;
483      /**
484       * @apilevel internal
485       */
486      protected int begin_label_value;
487      /**
488       * @attribute syn
489       * @aspect CreateBCode
490       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1359
491       */
492      @SuppressWarnings({"unchecked", "cast"})
493      public int begin_label() {
494        if(begin_label_computed) {
495          return begin_label_value;
496        }
497          ASTNode$State state = state();
498      int num = state.boundariesCrossed;
499      boolean isFinal = this.is$Final();
500        begin_label_value = begin_label_compute();
501      if(isFinal && num == state().boundariesCrossed){ begin_label_computed = true; }
502            return begin_label_value;
503      }
504      /**
505       * @apilevel internal
506       */
507      private int begin_label_compute() {  return hostType().constantPool().newLabel();  }
508      /**
509       * @apilevel internal
510       */
511      protected boolean cond_label_computed = false;
512      /**
513       * @apilevel internal
514       */
515      protected int cond_label_value;
516      /**
517       * @attribute syn
518       * @aspect CreateBCode
519       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1360
520       */
521      @SuppressWarnings({"unchecked", "cast"})
522      public int cond_label() {
523        if(cond_label_computed) {
524          return cond_label_value;
525        }
526          ASTNode$State state = state();
527      int num = state.boundariesCrossed;
528      boolean isFinal = this.is$Final();
529        cond_label_value = cond_label_compute();
530      if(isFinal && num == state().boundariesCrossed){ cond_label_computed = true; }
531            return cond_label_value;
532      }
533      /**
534       * @apilevel internal
535       */
536      private int cond_label_compute() {  return hostType().constantPool().newLabel();  }
537      /**
538       * @apilevel internal
539       */
540      protected boolean end_label_computed = false;
541      /**
542       * @apilevel internal
543       */
544      protected int end_label_value;
545      /**
546       * @attribute syn
547       * @aspect CreateBCode
548       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1361
549       */
550      @SuppressWarnings({"unchecked", "cast"})
551      public int end_label() {
552        if(end_label_computed) {
553          return end_label_value;
554        }
555          ASTNode$State state = state();
556      int num = state.boundariesCrossed;
557      boolean isFinal = this.is$Final();
558        end_label_value = end_label_compute();
559      if(isFinal && num == state().boundariesCrossed){ end_label_computed = true; }
560            return end_label_value;
561      }
562      /**
563       * @apilevel internal
564       */
565      private int end_label_compute() {  return hostType().constantPool().newLabel();  }
566      /**
567       * @attribute syn
568       * @aspect CreateBCode
569       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1398
570       */
571      public int break_label() {
572        ASTNode$State state = state();
573        try {  return end_label();  }
574        finally {
575        }
576      }
577      /**
578       * @attribute syn
579       * @aspect CreateBCode
580       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1417
581       */
582      public int continue_label() {
583        ASTNode$State state = state();
584        try {  return cond_label();  }
585        finally {
586        }
587      }
588      /**
589       * @attribute syn
590       * @aspect PreciseRethrow
591       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:55
592       */
593      public boolean modifiedInScope(Variable var) {
594        ASTNode$State state = state();
595        try {  return getStmt().modifiedInScope(var);  }
596        finally {
597        }
598      }
599      /**
600       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:600
601       * @apilevel internal
602       */
603      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
604        if(caller == getConditionNoTransform()){
605        if(!getStmt().isDAafter(v))
606          return false;
607        for(Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
608          ContinueStmt stmt = (ContinueStmt)iter.next();
609          if(!stmt.isDAafterReachedFinallyBlocks(v))
610            return false;
611        }
612        return true;
613      }
614        else if(caller == getStmtNoTransform()) {
615          return isDAbefore(v);
616        }
617        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
618        }
619      }
620      /**
621       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1081
622       * @apilevel internal
623       */
624      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
625        if(caller == getConditionNoTransform()) {
626          return isDUbeforeCondition(v);
627        }
628        else if(caller == getStmtNoTransform()) {
629          return isDUbefore(v) && getCondition().isDUafterTrue(v);
630        }
631        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
632        }
633      }
634      /**
635       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:372
636       * @apilevel internal
637       */
638      public boolean Define_boolean_insideLoop(ASTNode caller, ASTNode child) {
639        if(caller == getStmtNoTransform()) {
640          return true;
641        }
642        else {      return getParent().Define_boolean_insideLoop(this, caller);
643        }
644      }
645      /**
646       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:100
647       * @apilevel internal
648       */
649      public boolean Define_boolean_reachable(ASTNode caller, ASTNode child) {
650        if(caller == getStmtNoTransform()) {
651          return reachable();
652        }
653        else {      return getParent().Define_boolean_reachable(this, caller);
654        }
655      }
656      /**
657       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:152
658       * @apilevel internal
659       */
660      public boolean Define_boolean_reportUnreachable(ASTNode caller, ASTNode child) {
661        if(caller == getStmtNoTransform()) {
662          return reachable();
663        }
664        else {      return getParent().Define_boolean_reportUnreachable(this, caller);
665        }
666      }
667      /**
668       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:967
669       * @apilevel internal
670       */
671      public int Define_int_condition_false_label(ASTNode caller, ASTNode child) {
672        if(caller == getConditionNoTransform()) {
673          return end_label();
674        }
675        else {      return getParent().Define_int_condition_false_label(this, caller);
676        }
677      }
678      /**
679       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:968
680       * @apilevel internal
681       */
682      public int Define_int_condition_true_label(ASTNode caller, ASTNode child) {
683        if(caller == getConditionNoTransform()) {
684          return begin_label();
685        }
686        else {      return getParent().Define_int_condition_true_label(this, caller);
687        }
688      }
689      /**
690       * @apilevel internal
691       */
692      public ASTNode rewriteTo() {
693        return super.rewriteTo();
694      }
695    }