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 OrLogicalExpr : {@link LogicalExpr};
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:173
017     */
018    public class OrLogicalExpr extends LogicalExpr 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 OrLogicalExpr clone() throws CloneNotSupportedException {
034        OrLogicalExpr node = (OrLogicalExpr)super.clone();
035        node.isDAafterTrue_Variable_values = null;
036        node.isDAafterFalse_Variable_values = null;
037        node.isDAafter_Variable_values = null;
038        node.isDUafter_Variable_values = null;
039        node.next_test_label_computed = false;
040        node.in$Circle(false);
041        node.is$Final(false);
042        return node;
043      }
044    /**
045     * @apilevel internal
046     */
047      @SuppressWarnings({"unchecked", "cast"})
048    public OrLogicalExpr copy() {
049      
050      try {
051        OrLogicalExpr node = (OrLogicalExpr) clone();
052        node.parent = null;
053        if(children != null)
054          node.children = (ASTNode[]) children.clone();
055        
056        return node;
057      } catch (CloneNotSupportedException e) {
058        throw new Error("Error: clone not supported for " + getClass().getName());
059      }
060      
061    }/**
062     * Create a deep copy of the AST subtree at this node.
063     * The copy is dangling, i.e. has no parent.
064     * @return dangling copy of the subtree at this node
065     * @apilevel low-level
066     */
067      @SuppressWarnings({"unchecked", "cast"})
068    public OrLogicalExpr fullCopy() {
069      
070      OrLogicalExpr tree = (OrLogicalExpr) copy();
071      if (children != null) {
072        for (int i = 0; i < children.length; ++i) {
073          
074          ASTNode child = (ASTNode) children[i];
075          if(child != null) {
076            child = child.fullCopy();
077            tree.setChild(child, i);
078          }
079        }
080      }
081      return tree;
082      
083    }  /**
084       * @ast method 
085       * @aspect CreateBCode
086       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1097
087       */
088      public void emitEvalBranch(CodeGeneration gen) {
089        getLeftOperand().emitEvalBranch(gen);
090        gen.addLabel(next_test_label());
091        if(getLeftOperand().canBeFalse()) {
092          getRightOperand().emitEvalBranch(gen);
093          if(getRightOperand().canBeFalse())
094            gen.emitGoto(false_label());
095        }
096      }
097      /**
098       * @ast method 
099       * 
100       */
101      public OrLogicalExpr() {
102        super();
103    
104    
105      }
106      /**
107       * Initializes the child array to the correct size.
108       * Initializes List and Opt nta children.
109       * @apilevel internal
110       * @ast method
111       * @ast method 
112       * 
113       */
114      public void init$Children() {
115        children = new ASTNode[2];
116      }
117      /**
118       * @ast method 
119       * 
120       */
121      public OrLogicalExpr(Expr p0, Expr p1) {
122        setChild(p0, 0);
123        setChild(p1, 1);
124      }
125      /**
126       * @apilevel low-level
127       * @ast method 
128       * 
129       */
130      protected int numChildren() {
131        return 2;
132      }
133      /**
134       * @apilevel internal
135       * @ast method 
136       * 
137       */
138      public boolean mayHaveRewrite() {
139        return false;
140      }
141      /**
142       * Replaces the LeftOperand child.
143       * @param node The new node to replace the LeftOperand child.
144       * @apilevel high-level
145       * @ast method 
146       * 
147       */
148      public void setLeftOperand(Expr node) {
149        setChild(node, 0);
150      }
151      /**
152       * Retrieves the LeftOperand child.
153       * @return The current node used as the LeftOperand child.
154       * @apilevel high-level
155       * @ast method 
156       * 
157       */
158      public Expr getLeftOperand() {
159        return (Expr)getChild(0);
160      }
161      /**
162       * Retrieves the LeftOperand child.
163       * <p><em>This method does not invoke AST transformations.</em></p>
164       * @return The current node used as the LeftOperand child.
165       * @apilevel low-level
166       * @ast method 
167       * 
168       */
169      public Expr getLeftOperandNoTransform() {
170        return (Expr)getChildNoTransform(0);
171      }
172      /**
173       * Replaces the RightOperand child.
174       * @param node The new node to replace the RightOperand child.
175       * @apilevel high-level
176       * @ast method 
177       * 
178       */
179      public void setRightOperand(Expr node) {
180        setChild(node, 1);
181      }
182      /**
183       * Retrieves the RightOperand child.
184       * @return The current node used as the RightOperand child.
185       * @apilevel high-level
186       * @ast method 
187       * 
188       */
189      public Expr getRightOperand() {
190        return (Expr)getChild(1);
191      }
192      /**
193       * Retrieves the RightOperand child.
194       * <p><em>This method does not invoke AST transformations.</em></p>
195       * @return The current node used as the RightOperand child.
196       * @apilevel low-level
197       * @ast method 
198       * 
199       */
200      public Expr getRightOperandNoTransform() {
201        return (Expr)getChildNoTransform(1);
202      }
203      /**
204       * @attribute syn
205       * @aspect ConstantExpression
206       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:91
207       */
208      public Constant constant() {
209        ASTNode$State state = state();
210        try {  return Constant.create(left().constant().booleanValue() || right().constant().booleanValue());  }
211        finally {
212        }
213      }
214      protected java.util.Map isDAafterTrue_Variable_values;
215      /**
216       * @attribute syn
217       * @aspect DA
218       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:372
219       */
220      @SuppressWarnings({"unchecked", "cast"})
221      public boolean isDAafterTrue(Variable v) {
222        Object _parameters = v;
223        if(isDAafterTrue_Variable_values == null) isDAafterTrue_Variable_values = new java.util.HashMap(4);
224        if(isDAafterTrue_Variable_values.containsKey(_parameters)) {
225          return ((Boolean)isDAafterTrue_Variable_values.get(_parameters)).booleanValue();
226        }
227          ASTNode$State state = state();
228      int num = state.boundariesCrossed;
229      boolean isFinal = this.is$Final();
230        boolean isDAafterTrue_Variable_value = isDAafterTrue_compute(v);
231      if(isFinal && num == state().boundariesCrossed){ isDAafterTrue_Variable_values.put(_parameters, Boolean.valueOf(isDAafterTrue_Variable_value)); }
232            return isDAafterTrue_Variable_value;
233      }
234      /**
235       * @apilevel internal
236       */
237      private boolean isDAafterTrue_compute(Variable v) {  return (getLeftOperand().isDAafterTrue(v) && getRightOperand().isDAafterTrue(v)) || isFalse();  }
238      protected java.util.Map isDAafterFalse_Variable_values;
239      /**
240       * @attribute syn
241       * @aspect DA
242       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:373
243       */
244      @SuppressWarnings({"unchecked", "cast"})
245      public boolean isDAafterFalse(Variable v) {
246        Object _parameters = v;
247        if(isDAafterFalse_Variable_values == null) isDAafterFalse_Variable_values = new java.util.HashMap(4);
248        if(isDAafterFalse_Variable_values.containsKey(_parameters)) {
249          return ((Boolean)isDAafterFalse_Variable_values.get(_parameters)).booleanValue();
250        }
251          ASTNode$State state = state();
252      int num = state.boundariesCrossed;
253      boolean isFinal = this.is$Final();
254        boolean isDAafterFalse_Variable_value = isDAafterFalse_compute(v);
255      if(isFinal && num == state().boundariesCrossed){ isDAafterFalse_Variable_values.put(_parameters, Boolean.valueOf(isDAafterFalse_Variable_value)); }
256            return isDAafterFalse_Variable_value;
257      }
258      /**
259       * @apilevel internal
260       */
261      private boolean isDAafterFalse_compute(Variable v) {  return getRightOperand().isDAafterFalse(v) || isTrue();  }
262      protected java.util.Map isDAafter_Variable_values;
263      /**
264       * @attribute syn
265       * @aspect DA
266       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:376
267       */
268      @SuppressWarnings({"unchecked", "cast"})
269      public boolean isDAafter(Variable v) {
270        Object _parameters = v;
271        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
272        if(isDAafter_Variable_values.containsKey(_parameters)) {
273          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
274        }
275          ASTNode$State state = state();
276      int num = state.boundariesCrossed;
277      boolean isFinal = this.is$Final();
278        boolean isDAafter_Variable_value = isDAafter_compute(v);
279      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
280            return isDAafter_Variable_value;
281      }
282      /**
283       * @apilevel internal
284       */
285      private boolean isDAafter_compute(Variable v) {  return isDAafterTrue(v) && isDAafterFalse(v);  }
286      /**
287       * @attribute syn
288       * @aspect DU
289       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:702
290       */
291      public boolean isDUafterTrue(Variable v) {
292        ASTNode$State state = state();
293        try {  return getLeftOperand().isDUafterTrue(v) && getRightOperand().isDUafterTrue(v);  }
294        finally {
295        }
296      }
297      /**
298       * @attribute syn
299       * @aspect DU
300       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:703
301       */
302      public boolean isDUafterFalse(Variable v) {
303        ASTNode$State state = state();
304        try {  return getRightOperand().isDUafterFalse(v);  }
305        finally {
306        }
307      }
308      protected java.util.Map isDUafter_Variable_values;
309      /**
310       * @attribute syn
311       * @aspect DU
312       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:812
313       */
314      @SuppressWarnings({"unchecked", "cast"})
315      public boolean isDUafter(Variable v) {
316        Object _parameters = v;
317        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
318        if(isDUafter_Variable_values.containsKey(_parameters)) {
319          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
320        }
321          ASTNode$State state = state();
322      int num = state.boundariesCrossed;
323      boolean isFinal = this.is$Final();
324        boolean isDUafter_Variable_value = isDUafter_compute(v);
325      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
326            return isDUafter_Variable_value;
327      }
328      /**
329       * @apilevel internal
330       */
331      private boolean isDUafter_compute(Variable v) {  return isDUafterTrue(v) && isDUafterFalse(v);  }
332      /**
333       * @attribute syn
334       * @aspect PrettyPrint
335       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:400
336       */
337      public String printOp() {
338        ASTNode$State state = state();
339        try {  return " || ";  }
340        finally {
341        }
342      }
343      /**
344       * @attribute syn
345       * @aspect CreateBCode
346       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1007
347       */
348      public boolean canBeTrue() {
349        ASTNode$State state = state();
350        try {  return getLeftOperand().canBeTrue() || getRightOperand().canBeTrue();  }
351        finally {
352        }
353      }
354      /**
355       * @attribute syn
356       * @aspect CreateBCode
357       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1017
358       */
359      public boolean canBeFalse() {
360        ASTNode$State state = state();
361        try {  return getLeftOperand().canBeFalse() && getRightOperand().canBeFalse();  }
362        finally {
363        }
364      }
365      /**
366       * @apilevel internal
367       */
368      protected boolean next_test_label_computed = false;
369      /**
370       * @apilevel internal
371       */
372      protected int next_test_label_value;
373      /**
374       * @attribute syn
375       * @aspect CreateBCode
376       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1106
377       */
378      @SuppressWarnings({"unchecked", "cast"})
379      public int next_test_label() {
380        if(next_test_label_computed) {
381          return next_test_label_value;
382        }
383          ASTNode$State state = state();
384      int num = state.boundariesCrossed;
385      boolean isFinal = this.is$Final();
386        next_test_label_value = next_test_label_compute();
387      if(isFinal && num == state().boundariesCrossed){ next_test_label_computed = true; }
388            return next_test_label_value;
389      }
390      /**
391       * @apilevel internal
392       */
393      private int next_test_label_compute() {  return hostType().constantPool().newLabel();  }
394      /**
395       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:375
396       * @apilevel internal
397       */
398      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
399        if(caller == getRightOperandNoTransform()) {
400          return getLeftOperand().isDAafterFalse(v);
401        }
402        else if(caller == getLeftOperandNoTransform()) {
403          return isDAbefore(v);
404        }
405        else {      return super.Define_boolean_isDAbefore(caller, child, v);
406        }
407      }
408      /**
409       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:811
410       * @apilevel internal
411       */
412      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
413        if(caller == getRightOperandNoTransform()) {
414          return getLeftOperand().isDUafterFalse(v);
415        }
416        else if(caller == getLeftOperandNoTransform()) {
417          return isDUbefore(v);
418        }
419        else {      return super.Define_boolean_isDUbefore(caller, child, v);
420        }
421      }
422      /**
423       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1004
424       * @apilevel internal
425       */
426      public int Define_int_condition_false_label(ASTNode caller, ASTNode child) {
427        if(caller == getRightOperandNoTransform()) {
428          return false_label();
429        }
430        else if(caller == getLeftOperandNoTransform()) {
431          return next_test_label();
432        }
433        else {      return getParent().Define_int_condition_false_label(this, caller);
434        }
435      }
436      /**
437       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1005
438       * @apilevel internal
439       */
440      public int Define_int_condition_true_label(ASTNode caller, ASTNode child) {
441        if(caller == getRightOperandNoTransform()) {
442          return true_label();
443        }
444        else if(caller == getLeftOperandNoTransform()) {
445          return true_label();
446        }
447        else {      return getParent().Define_int_condition_true_label(this, caller);
448        }
449      }
450      /**
451       * @apilevel internal
452       */
453      public ASTNode rewriteTo() {
454        return super.rewriteTo();
455      }
456    }