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 ConditionalExpr : {@link Expr} ::= <span class="component">Condition:{@link Expr}</span> <span class="component">TrueExpr:{@link Expr}</span> <span class="component">FalseExpr:{@link Expr}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:188
017     */
018    public class ConditionalExpr extends Expr 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 ConditionalExpr clone() throws CloneNotSupportedException {
034        ConditionalExpr node = (ConditionalExpr)super.clone();
035        node.constant_computed = false;
036        node.constant_value = null;
037        node.isConstant_computed = false;
038        node.booleanOperator_computed = false;
039        node.type_computed = false;
040        node.type_value = null;
041        node.else_branch_label_computed = false;
042        node.then_branch_label_computed = false;
043        node.in$Circle(false);
044        node.is$Final(false);
045        return node;
046      }
047    /**
048     * @apilevel internal
049     */
050      @SuppressWarnings({"unchecked", "cast"})
051    public ConditionalExpr copy() {
052      
053      try {
054        ConditionalExpr node = (ConditionalExpr) clone();
055        node.parent = null;
056        if(children != null)
057          node.children = (ASTNode[]) children.clone();
058        
059        return node;
060      } catch (CloneNotSupportedException e) {
061        throw new Error("Error: clone not supported for " + getClass().getName());
062      }
063      
064    }/**
065     * Create a deep copy of the AST subtree at this node.
066     * The copy is dangling, i.e. has no parent.
067     * @return dangling copy of the subtree at this node
068     * @apilevel low-level
069     */
070      @SuppressWarnings({"unchecked", "cast"})
071    public ConditionalExpr fullCopy() {
072      
073      ConditionalExpr tree = (ConditionalExpr) copy();
074      if (children != null) {
075        for (int i = 0; i < children.length; ++i) {
076          
077          ASTNode child = (ASTNode) children[i];
078          if(child != null) {
079            child = child.fullCopy();
080            tree.setChild(child, i);
081          }
082        }
083      }
084      return tree;
085      
086    }  /**
087       * @ast method 
088       * @aspect PrettyPrint
089       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:427
090       */
091      public void toString(StringBuffer s) {
092        getCondition().toString(s);
093        s.append(" ? ");
094        getTrueExpr().toString(s);
095        s.append(" : ");
096        getFalseExpr().toString(s);
097      }
098      /**
099       * @ast method 
100       * @aspect TypeCheck
101       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:562
102       */
103      public void typeCheck() {
104        if(!getCondition().type().isBoolean())
105          error("The first operand of a conditional expression must be a boolean");
106        if(type().isUnknown() && !getTrueExpr().type().isUnknown() && !getFalseExpr().type().isUnknown()) {
107          error("The types of the second and third operand in this conditional expression do not match"); 
108        }
109      }
110      /**
111       * @ast method 
112       * @aspect CreateBCode
113       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1042
114       */
115      public void createBCode(CodeGeneration gen) {
116        if(type().isBoolean())
117          emitBooleanCondition(gen);
118        else {
119          int endBranch = hostType().constantPool().newLabel();
120          getCondition().emitEvalBranch(gen);
121          if(getCondition().canBeTrue()) {
122            gen.addLabel(then_branch_label());
123            getTrueExpr().createBCode(gen);
124            getTrueExpr().type().emitCastTo(gen, type());
125            if(getCondition().canBeFalse()) {
126              gen.changeStackDepth(-type().variableSize());
127              gen.emitGoto(endBranch);
128            }
129          }
130          if(getCondition().canBeFalse()) {
131            gen.addLabel(else_branch_label());
132            getFalseExpr().createBCode(gen);
133            getFalseExpr().type().emitCastTo(gen, type());
134          }
135          gen.addLabel(endBranch);
136        }
137      }
138      /**
139       * @ast method 
140       * @aspect CreateBCode
141       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1108
142       */
143      public void emitEvalBranch(CodeGeneration gen) {
144        int endBranch = hostType().constantPool().newLabel();
145        getCondition().emitEvalBranch(gen);
146        gen.addLabel(then_branch_label());
147        if(getCondition().canBeTrue()) {
148          getTrueExpr().emitEvalBranch(gen);
149          gen.emitGoto(true_label());
150        }  
151        gen.addLabel(else_branch_label());
152        if(getCondition().canBeFalse()) {
153          getFalseExpr().emitEvalBranch(gen);
154          gen.emitGoto(true_label());
155        }
156      }
157      /**
158       * @ast method 
159       * @aspect AutoBoxingCodegen
160       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/AutoBoxingCodegen.jrag:385
161       */
162      public void emitBooleanCondition(CodeGeneration gen) {
163        super.emitBooleanCondition(gen);
164        if(type().isReferenceType())
165          type().emitBoxingOperation(gen);
166      }
167      /**
168       * @ast method 
169       * 
170       */
171      public ConditionalExpr() {
172        super();
173    
174    
175      }
176      /**
177       * Initializes the child array to the correct size.
178       * Initializes List and Opt nta children.
179       * @apilevel internal
180       * @ast method
181       * @ast method 
182       * 
183       */
184      public void init$Children() {
185        children = new ASTNode[3];
186      }
187      /**
188       * @ast method 
189       * 
190       */
191      public ConditionalExpr(Expr p0, Expr p1, Expr p2) {
192        setChild(p0, 0);
193        setChild(p1, 1);
194        setChild(p2, 2);
195      }
196      /**
197       * @apilevel low-level
198       * @ast method 
199       * 
200       */
201      protected int numChildren() {
202        return 3;
203      }
204      /**
205       * @apilevel internal
206       * @ast method 
207       * 
208       */
209      public boolean mayHaveRewrite() {
210        return false;
211      }
212      /**
213       * Replaces the Condition child.
214       * @param node The new node to replace the Condition child.
215       * @apilevel high-level
216       * @ast method 
217       * 
218       */
219      public void setCondition(Expr node) {
220        setChild(node, 0);
221      }
222      /**
223       * Retrieves the Condition child.
224       * @return The current node used as the Condition child.
225       * @apilevel high-level
226       * @ast method 
227       * 
228       */
229      public Expr getCondition() {
230        return (Expr)getChild(0);
231      }
232      /**
233       * Retrieves the Condition child.
234       * <p><em>This method does not invoke AST transformations.</em></p>
235       * @return The current node used as the Condition child.
236       * @apilevel low-level
237       * @ast method 
238       * 
239       */
240      public Expr getConditionNoTransform() {
241        return (Expr)getChildNoTransform(0);
242      }
243      /**
244       * Replaces the TrueExpr child.
245       * @param node The new node to replace the TrueExpr child.
246       * @apilevel high-level
247       * @ast method 
248       * 
249       */
250      public void setTrueExpr(Expr node) {
251        setChild(node, 1);
252      }
253      /**
254       * Retrieves the TrueExpr child.
255       * @return The current node used as the TrueExpr child.
256       * @apilevel high-level
257       * @ast method 
258       * 
259       */
260      public Expr getTrueExpr() {
261        return (Expr)getChild(1);
262      }
263      /**
264       * Retrieves the TrueExpr child.
265       * <p><em>This method does not invoke AST transformations.</em></p>
266       * @return The current node used as the TrueExpr child.
267       * @apilevel low-level
268       * @ast method 
269       * 
270       */
271      public Expr getTrueExprNoTransform() {
272        return (Expr)getChildNoTransform(1);
273      }
274      /**
275       * Replaces the FalseExpr child.
276       * @param node The new node to replace the FalseExpr child.
277       * @apilevel high-level
278       * @ast method 
279       * 
280       */
281      public void setFalseExpr(Expr node) {
282        setChild(node, 2);
283      }
284      /**
285       * Retrieves the FalseExpr child.
286       * @return The current node used as the FalseExpr child.
287       * @apilevel high-level
288       * @ast method 
289       * 
290       */
291      public Expr getFalseExpr() {
292        return (Expr)getChild(2);
293      }
294      /**
295       * Retrieves the FalseExpr child.
296       * <p><em>This method does not invoke AST transformations.</em></p>
297       * @return The current node used as the FalseExpr child.
298       * @apilevel low-level
299       * @ast method 
300       * 
301       */
302      public Expr getFalseExprNoTransform() {
303        return (Expr)getChildNoTransform(2);
304      }
305      /**
306       * @ast method 
307       * @aspect TypeAnalysis
308       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:364
309       */
310      private TypeDecl refined_TypeAnalysis_ConditionalExpr_type()
311    {
312        TypeDecl trueType = getTrueExpr().type();
313        TypeDecl falseType = getFalseExpr().type();
314        
315        if(trueType == falseType) return trueType;
316        
317        if(trueType.isNumericType() && falseType.isNumericType()) {
318          if(trueType.isByte() && falseType.isShort()) return falseType;
319          if(trueType.isShort() && falseType.isByte()) return trueType;
320          if((trueType.isByte() || trueType.isShort() || trueType.isChar()) && 
321             falseType.isInt() && getFalseExpr().isConstant() && getFalseExpr().representableIn(trueType))
322            return trueType;
323          if((falseType.isByte() || falseType.isShort() || falseType.isChar()) && 
324             trueType.isInt() && getTrueExpr().isConstant() && getTrueExpr().representableIn(falseType))
325            return falseType;
326          return trueType.binaryNumericPromotion(falseType);
327        }
328        else if(trueType.isBoolean() && falseType.isBoolean()) {
329          return trueType;
330        }
331        else if(trueType.isReferenceType() && falseType.isNull()) {
332          return trueType;
333        }
334        else if(trueType.isNull() && falseType.isReferenceType()) {
335          return falseType;
336        }
337        else if(trueType.isReferenceType() && falseType.isReferenceType()) {
338          if(trueType.assignConversionTo(falseType, null))
339            return falseType;
340          if(falseType.assignConversionTo(trueType, null))
341            return trueType;
342          return unknownType();
343        }
344        else
345          return unknownType();
346      }
347      /**
348       * @ast method 
349       * @aspect AutoBoxing
350       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/AutoBoxing.jrag:181
351       */
352      private TypeDecl refined_AutoBoxing_ConditionalExpr_type()
353    {
354        TypeDecl trueType = getTrueExpr().type();
355        TypeDecl falseType = getFalseExpr().type();
356        if(trueType.isBoolean() && falseType.isBoolean()) {
357          if(trueType == falseType)
358            return trueType;
359          if(trueType.isReferenceType())
360            return trueType.unboxed();
361          return trueType;
362        }
363        return refined_TypeAnalysis_ConditionalExpr_type();
364      }
365      /**
366       * @apilevel internal
367       */
368      protected boolean constant_computed = false;
369      /**
370       * @apilevel internal
371       */
372      protected Constant constant_value;
373      /**
374       * @attribute syn
375       * @aspect ConstantExpression
376       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:125
377       */
378      @SuppressWarnings({"unchecked", "cast"})
379      public Constant constant() {
380        if(constant_computed) {
381          return constant_value;
382        }
383          ASTNode$State state = state();
384      int num = state.boundariesCrossed;
385      boolean isFinal = this.is$Final();
386        constant_value = constant_compute();
387      if(isFinal && num == state().boundariesCrossed){ constant_computed = true; }
388            return constant_value;
389      }
390      /**
391       * @apilevel internal
392       */
393      private Constant constant_compute() {  return type().questionColon(getCondition().constant(), getTrueExpr().constant(),getFalseExpr().constant());  }
394      /**
395       * @apilevel internal
396       */
397      protected boolean isConstant_computed = false;
398      /**
399       * @apilevel internal
400       */
401      protected boolean isConstant_value;
402      /**
403       * @attribute syn
404       * @aspect ConstantExpression
405       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:347
406       */
407      @SuppressWarnings({"unchecked", "cast"})
408      public boolean isConstant() {
409        if(isConstant_computed) {
410          return isConstant_value;
411        }
412          ASTNode$State state = state();
413      int num = state.boundariesCrossed;
414      boolean isFinal = this.is$Final();
415        isConstant_value = isConstant_compute();
416      if(isFinal && num == state().boundariesCrossed){ isConstant_computed = true; }
417            return isConstant_value;
418      }
419      /**
420       * @apilevel internal
421       */
422      private boolean isConstant_compute() {  return getCondition().isConstant() && getTrueExpr().isConstant() && getFalseExpr().isConstant();  }
423      /**
424       * @apilevel internal
425       */
426      protected boolean booleanOperator_computed = false;
427      /**
428       * @apilevel internal
429       */
430      protected boolean booleanOperator_value;
431      /**
432       * @attribute syn
433       * @aspect DA
434       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:230
435       */
436      @SuppressWarnings({"unchecked", "cast"})
437      public boolean booleanOperator() {
438        if(booleanOperator_computed) {
439          return booleanOperator_value;
440        }
441          ASTNode$State state = state();
442      int num = state.boundariesCrossed;
443      boolean isFinal = this.is$Final();
444        booleanOperator_value = booleanOperator_compute();
445      if(isFinal && num == state().boundariesCrossed){ booleanOperator_computed = true; }
446            return booleanOperator_value;
447      }
448      /**
449       * @apilevel internal
450       */
451      private boolean booleanOperator_compute() {  return getTrueExpr().type().isBoolean() && getFalseExpr().type().isBoolean();  }
452      /*eq Stmt.isDAafter(Variable v) {
453        //System.out.println("### isDAafter reached in " + getClass().getName());
454        //throw new NullPointerException();
455        throw new Error("Can not compute isDAafter for " + getClass().getName() + " at " + errorPrefix());
456      }* @attribute syn
457       * @aspect DA
458       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:332
459       */
460      public boolean isDAafterTrue(Variable v) {
461        ASTNode$State state = state();
462        try {  return (getTrueExpr().isDAafterTrue(v) && getFalseExpr().isDAafterTrue(v)) || isFalse();  }
463        finally {
464        }
465      }
466      /**
467       * @attribute syn
468       * @aspect DA
469       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:333
470       */
471      public boolean isDAafterFalse(Variable v) {
472        ASTNode$State state = state();
473        try {  return (getTrueExpr().isDAafterFalse(v) && getFalseExpr().isDAafterFalse(v)) || isTrue();  }
474        finally {
475        }
476      }
477      /**
478       * @attribute syn
479       * @aspect DA
480       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:235
481       */
482      public boolean isDAafter(Variable v) {
483        ASTNode$State state = state();
484        try {  return booleanOperator() ? isDAafterTrue(v) && isDAafterFalse(v) : getTrueExpr().isDAafter(v) && getFalseExpr().isDAafter(v);  }
485        finally {
486        }
487      }
488      /**
489       * @attribute syn
490       * @aspect DU
491       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:702
492       */
493      public boolean isDUafterTrue(Variable v) {
494        ASTNode$State state = state();
495        try {  return getTrueExpr().isDUafterTrue(v) && getFalseExpr().isDUafterTrue(v);  }
496        finally {
497        }
498      }
499      /**
500       * @attribute syn
501       * @aspect DU
502       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:703
503       */
504      public boolean isDUafterFalse(Variable v) {
505        ASTNode$State state = state();
506        try {  return getTrueExpr().isDUafterFalse(v) && getFalseExpr().isDUafterFalse(v);  }
507        finally {
508        }
509      }
510      /**
511       * @attribute syn
512       * @aspect DU
513       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:694
514       */
515      public boolean isDUafter(Variable v) {
516        ASTNode$State state = state();
517        try {  return booleanOperator() ? isDUafterTrue(v) && isDUafterFalse(v) : getTrueExpr().isDUafter(v) && getFalseExpr().isDUafter(v);  }
518        finally {
519        }
520      }
521      /**
522       * @apilevel internal
523       */
524      protected boolean type_computed = false;
525      /**
526       * @apilevel internal
527       */
528      protected TypeDecl type_value;
529      /**
530       * @attribute syn
531       * @aspect Generics
532       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:129
533       */
534      @SuppressWarnings({"unchecked", "cast"})
535      public TypeDecl type() {
536        if(type_computed) {
537          return type_value;
538        }
539          ASTNode$State state = state();
540      int num = state.boundariesCrossed;
541      boolean isFinal = this.is$Final();
542        type_value = type_compute();
543      if(isFinal && num == state().boundariesCrossed){ type_computed = true; }
544            return type_value;
545      }
546      /**
547       * @apilevel internal
548       */
549      private TypeDecl type_compute() {
550        TypeDecl type = refined_AutoBoxing_ConditionalExpr_type();
551        TypeDecl trueType = getTrueExpr().type();
552        TypeDecl falseType = getFalseExpr().type();
553    
554        if(type.isUnknown()) {
555          if(!trueType.isReferenceType() && !trueType.boxed().isUnknown())
556            trueType = trueType.boxed();
557          if(!falseType.isReferenceType() && !falseType.boxed().isUnknown())
558            falseType = falseType.boxed();
559    
560          ArrayList list = new ArrayList();
561          list.add(trueType);
562          list.add(falseType);
563          return type.lookupLUBType(list);
564        }
565        return type;
566      }
567      /**
568       * @attribute syn
569       * @aspect CreateBCode
570       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:946
571       */
572      public boolean definesLabel() {
573        ASTNode$State state = state();
574        try {  return true;  }
575        finally {
576        }
577      }
578      /**
579       * @attribute syn
580       * @aspect CreateBCode
581       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1007
582       */
583      public boolean canBeTrue() {
584        ASTNode$State state = state();
585        try {  return type().isBoolean() && (getTrueExpr().canBeTrue() && getFalseExpr().canBeTrue() 
586        || getCondition().isTrue() && getTrueExpr().canBeTrue()
587        || getCondition().isFalse() && getFalseExpr().canBeTrue());  }
588        finally {
589        }
590      }
591      /**
592       * @attribute syn
593       * @aspect CreateBCode
594       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1017
595       */
596      public boolean canBeFalse() {
597        ASTNode$State state = state();
598        try {  return type().isBoolean() && (getTrueExpr().canBeFalse() && getFalseExpr().canBeFalse() 
599        || getCondition().isTrue() && getTrueExpr().canBeFalse()
600        || getCondition().isFalse() && getFalseExpr().canBeFalse());  }
601        finally {
602        }
603      }
604      /**
605       * @apilevel internal
606       */
607      protected boolean else_branch_label_computed = false;
608      /**
609       * @apilevel internal
610       */
611      protected int else_branch_label_value;
612      /**
613       * @attribute syn
614       * @aspect CreateBCode
615       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1065
616       */
617      @SuppressWarnings({"unchecked", "cast"})
618      public int else_branch_label() {
619        if(else_branch_label_computed) {
620          return else_branch_label_value;
621        }
622          ASTNode$State state = state();
623      int num = state.boundariesCrossed;
624      boolean isFinal = this.is$Final();
625        else_branch_label_value = else_branch_label_compute();
626      if(isFinal && num == state().boundariesCrossed){ else_branch_label_computed = true; }
627            return else_branch_label_value;
628      }
629      /**
630       * @apilevel internal
631       */
632      private int else_branch_label_compute() {  return hostType().constantPool().newLabel();  }
633      /**
634       * @apilevel internal
635       */
636      protected boolean then_branch_label_computed = false;
637      /**
638       * @apilevel internal
639       */
640      protected int then_branch_label_value;
641      /**
642       * @attribute syn
643       * @aspect CreateBCode
644       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1066
645       */
646      @SuppressWarnings({"unchecked", "cast"})
647      public int then_branch_label() {
648        if(then_branch_label_computed) {
649          return then_branch_label_value;
650        }
651          ASTNode$State state = state();
652      int num = state.boundariesCrossed;
653      boolean isFinal = this.is$Final();
654        then_branch_label_value = then_branch_label_compute();
655      if(isFinal && num == state().boundariesCrossed){ then_branch_label_computed = true; }
656            return then_branch_label_value;
657      }
658      /**
659       * @apilevel internal
660       */
661      private int then_branch_label_compute() {  return hostType().constantPool().newLabel();  }
662      /**
663       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:387
664       * @apilevel internal
665       */
666      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
667        if(caller == getFalseExprNoTransform()) {
668          return getCondition().isDAafterFalse(v);
669        }
670        else if(caller == getTrueExprNoTransform()) {
671          return getCondition().isDAafterTrue(v);
672        }
673        else if(caller == getConditionNoTransform()) {
674          return isDAbefore(v);
675        }
676        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
677        }
678      }
679      /**
680       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:823
681       * @apilevel internal
682       */
683      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
684        if(caller == getFalseExprNoTransform()) {
685          return getCondition().isDUafterFalse(v);
686        }
687        else if(caller == getTrueExprNoTransform()) {
688          return getCondition().isDUafterTrue(v);
689        }
690        else if(caller == getConditionNoTransform()) {
691          return isDUbefore(v);
692        }
693        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
694        }
695      }
696      /**
697       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:989
698       * @apilevel internal
699       */
700      public int Define_int_condition_false_label(ASTNode caller, ASTNode child) {
701        if(caller == getFalseExprNoTransform()) {
702          return false_label();
703        }
704        else if(caller == getTrueExprNoTransform()) {
705          return false_label();
706        }
707        else if(caller == getConditionNoTransform()) {
708          return else_branch_label();
709        }
710        else {      return getParent().Define_int_condition_false_label(this, caller);
711        }
712      }
713      /**
714       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:990
715       * @apilevel internal
716       */
717      public int Define_int_condition_true_label(ASTNode caller, ASTNode child) {
718        if(caller == getFalseExprNoTransform()) {
719          return true_label();
720        }
721        else if(caller == getTrueExprNoTransform()) {
722          return true_label();
723        }
724        else if(caller == getConditionNoTransform()) {
725          return then_branch_label();
726        }
727        else {      return getParent().Define_int_condition_true_label(this, caller);
728        }
729      }
730      /**
731       * @apilevel internal
732       */
733      public ASTNode rewriteTo() {
734        return super.rewriteTo();
735      }
736    }