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:170
027     * @production OrLogicalExpr : {@link LogicalExpr};
028    
029     */
030    public class OrLogicalExpr extends LogicalExpr implements Cloneable {
031      /**
032       * @aspect CreateBCode
033       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1157
034       */
035      public void branchTrue(CodeGeneration gen, int target) {
036        // branch when true
037        Expr left = getLeftOperand();
038        Expr right = getRightOperand();
039        if (!left.isFalse()) {
040          left.branchTrue(gen, target);
041        }
042        if (left.canBeFalse()) {
043          right.branchTrue(gen, target);
044        }
045      }
046      /**
047       * @aspect CreateBCode
048       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1267
049       */
050      public void branchFalse(CodeGeneration gen, int target) {
051        // branch when false
052        Expr left = getLeftOperand();
053        Expr right = getRightOperand();
054        int skip_lbl = -1;
055        if (!left.isConstant()) {
056          skip_lbl = gen.constantPool().newLabel();
057          left.branchTrue(gen, skip_lbl);
058        }
059        if (left.canBeFalse()) {
060          right.branchFalse(gen, target);
061        }
062        if (skip_lbl != -1) {
063          gen.addLabel(skip_lbl);
064        }
065      }
066      /**
067       * @declaredat ASTNode:1
068       */
069      public OrLogicalExpr() {
070        super();
071      }
072      /**
073       * Initializes the child array to the correct size.
074       * Initializes List and Opt nta children.
075       * @apilevel internal
076       * @ast method
077       * @declaredat ASTNode:10
078       */
079      public void init$Children() {
080        children = new ASTNode[2];
081      }
082      /**
083       * @declaredat ASTNode:13
084       */
085      public OrLogicalExpr(Expr p0, Expr p1) {
086        setChild(p0, 0);
087        setChild(p1, 1);
088      }
089      /**
090       * @apilevel low-level
091       * @declaredat ASTNode:20
092       */
093      protected int numChildren() {
094        return 2;
095      }
096      /**
097       * @apilevel internal
098       * @declaredat ASTNode:26
099       */
100      public boolean mayHaveRewrite() {
101        return false;
102      }
103      /**
104       * @apilevel internal
105       * @declaredat ASTNode:32
106       */
107      public void flushAttrCache() {
108        super.flushAttrCache();
109        isDAafterTrue_Variable_reset();
110        isDAafterFalse_Variable_reset();
111        isDAafter_Variable_reset();
112        isDUafter_Variable_reset();
113      }
114      /**
115       * @apilevel internal
116       * @declaredat ASTNode:42
117       */
118      public void flushCollectionCache() {
119        super.flushCollectionCache();
120      }
121      /**
122       * @apilevel internal
123       * @declaredat ASTNode:48
124       */
125      public void flushRewriteCache() {
126        super.flushRewriteCache();
127      }
128      /**
129       * @apilevel internal
130       * @declaredat ASTNode:54
131       */
132      public OrLogicalExpr clone() throws CloneNotSupportedException {
133        OrLogicalExpr node = (OrLogicalExpr) super.clone();
134        return node;
135      }
136      /**
137       * @apilevel internal
138       * @declaredat ASTNode:61
139       */
140      public OrLogicalExpr copy() {
141        try {
142          OrLogicalExpr node = (OrLogicalExpr) clone();
143          node.parent = null;
144          if (children != null) {
145            node.children = (ASTNode[]) children.clone();
146          }
147          return node;
148        } catch (CloneNotSupportedException e) {
149          throw new Error("Error: clone not supported for " + getClass().getName());
150        }
151      }
152      /**
153       * Create a deep copy of the AST subtree at this node.
154       * The copy is dangling, i.e. has no parent.
155       * @return dangling copy of the subtree at this node
156       * @apilevel low-level
157       * @deprecated Please use treeCopy or treeCopyNoTransform instead
158       * @declaredat ASTNode:80
159       */
160      @Deprecated
161      public OrLogicalExpr fullCopy() {
162        return treeCopyNoTransform();
163      }
164      /**
165       * Create a deep copy of the AST subtree at this node.
166       * The copy is dangling, i.e. has no parent.
167       * @return dangling copy of the subtree at this node
168       * @apilevel low-level
169       * @declaredat ASTNode:90
170       */
171      public OrLogicalExpr treeCopyNoTransform() {
172        OrLogicalExpr tree = (OrLogicalExpr) copy();
173        if (children != null) {
174          for (int i = 0; i < children.length; ++i) {
175            ASTNode child = (ASTNode) children[i];
176            if (child != null) {
177              child = child.treeCopyNoTransform();
178              tree.setChild(child, i);
179            }
180          }
181        }
182        return tree;
183      }
184      /**
185       * Create a deep copy of the AST subtree at this node.
186       * The subtree of this node is traversed to trigger rewrites before copy.
187       * The copy is dangling, i.e. has no parent.
188       * @return dangling copy of the subtree at this node
189       * @apilevel low-level
190       * @declaredat ASTNode:110
191       */
192      public OrLogicalExpr treeCopy() {
193        doFullTraversal();
194        return treeCopyNoTransform();
195      }
196      /**
197       * @apilevel internal
198       * @declaredat ASTNode:117
199       */
200      protected boolean is$Equal(ASTNode node) {
201        return super.is$Equal(node);    
202      }
203      /**
204       * Replaces the LeftOperand child.
205       * @param node The new node to replace the LeftOperand child.
206       * @apilevel high-level
207       */
208      public void setLeftOperand(Expr node) {
209        setChild(node, 0);
210      }
211      /**
212       * Retrieves the LeftOperand child.
213       * @return The current node used as the LeftOperand child.
214       * @apilevel high-level
215       */
216      @ASTNodeAnnotation.Child(name="LeftOperand")
217      public Expr getLeftOperand() {
218        return (Expr) getChild(0);
219      }
220      /**
221       * Retrieves the LeftOperand child.
222       * <p><em>This method does not invoke AST transformations.</em></p>
223       * @return The current node used as the LeftOperand child.
224       * @apilevel low-level
225       */
226      public Expr getLeftOperandNoTransform() {
227        return (Expr) getChildNoTransform(0);
228      }
229      /**
230       * Replaces the RightOperand child.
231       * @param node The new node to replace the RightOperand child.
232       * @apilevel high-level
233       */
234      public void setRightOperand(Expr node) {
235        setChild(node, 1);
236      }
237      /**
238       * Retrieves the RightOperand child.
239       * @return The current node used as the RightOperand child.
240       * @apilevel high-level
241       */
242      @ASTNodeAnnotation.Child(name="RightOperand")
243      public Expr getRightOperand() {
244        return (Expr) getChild(1);
245      }
246      /**
247       * Retrieves the RightOperand child.
248       * <p><em>This method does not invoke AST transformations.</em></p>
249       * @return The current node used as the RightOperand child.
250       * @apilevel low-level
251       */
252      public Expr getRightOperandNoTransform() {
253        return (Expr) getChildNoTransform(1);
254      }
255      /**
256       * @attribute syn
257       * @aspect ConstantExpression
258       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:32
259       */
260      @ASTNodeAnnotation.Attribute
261      public Constant constant() {
262        Constant constant_value = Constant.create(left().constant().booleanValue() || right().constant().booleanValue());
263    
264        return constant_value;
265      }
266      /**
267       * @apilevel internal
268       */
269      protected java.util.Map isDAafterTrue_Variable_values;
270      /**
271       * @apilevel internal
272       */
273      private void isDAafterTrue_Variable_reset() {
274        isDAafterTrue_Variable_values = null;
275      }
276      /**
277       * @attribute syn
278       * @aspect DA
279       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:442
280       */
281      @ASTNodeAnnotation.Attribute
282      public boolean isDAafterTrue(Variable v) {
283        Object _parameters = v;
284        if (isDAafterTrue_Variable_values == null) isDAafterTrue_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
285        ASTNode$State state = state();
286        if (isDAafterTrue_Variable_values.containsKey(_parameters)) {
287          return (Boolean) isDAafterTrue_Variable_values.get(_parameters);
288        }
289        boolean intermediate = state.INTERMEDIATE_VALUE;
290        state.INTERMEDIATE_VALUE = false;
291        int num = state.boundariesCrossed;
292        boolean isFinal = this.is$Final();
293        boolean isDAafterTrue_Variable_value = isFalse() || (getLeftOperand().isDAafterTrue(v) && getRightOperand().isDAafterTrue(v));
294        if (isFinal && num == state().boundariesCrossed) {
295          isDAafterTrue_Variable_values.put(_parameters, isDAafterTrue_Variable_value);
296        } else {
297        }
298        state.INTERMEDIATE_VALUE |= intermediate;
299    
300        return isDAafterTrue_Variable_value;
301      }
302      /**
303       * @apilevel internal
304       */
305      protected java.util.Map isDAafterFalse_Variable_values;
306      /**
307       * @apilevel internal
308       */
309      private void isDAafterFalse_Variable_reset() {
310        isDAafterFalse_Variable_values = null;
311      }
312      /**
313       * @attribute syn
314       * @aspect DA
315       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:443
316       */
317      @ASTNodeAnnotation.Attribute
318      public boolean isDAafterFalse(Variable v) {
319        Object _parameters = v;
320        if (isDAafterFalse_Variable_values == null) isDAafterFalse_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
321        ASTNode$State state = state();
322        if (isDAafterFalse_Variable_values.containsKey(_parameters)) {
323          return (Boolean) isDAafterFalse_Variable_values.get(_parameters);
324        }
325        boolean intermediate = state.INTERMEDIATE_VALUE;
326        state.INTERMEDIATE_VALUE = false;
327        int num = state.boundariesCrossed;
328        boolean isFinal = this.is$Final();
329        boolean isDAafterFalse_Variable_value = isTrue() || getRightOperand().isDAafterFalse(v);
330        if (isFinal && num == state().boundariesCrossed) {
331          isDAafterFalse_Variable_values.put(_parameters, isDAafterFalse_Variable_value);
332        } else {
333        }
334        state.INTERMEDIATE_VALUE |= intermediate;
335    
336        return isDAafterFalse_Variable_value;
337      }
338      /**
339       * @apilevel internal
340       */
341      protected java.util.Map isDAafter_Variable_values;
342      /**
343       * @apilevel internal
344       */
345      private void isDAafter_Variable_reset() {
346        isDAafter_Variable_values = null;
347      }
348      /**
349       * @attribute syn
350       * @aspect DA
351       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:261
352       */
353      @ASTNodeAnnotation.Attribute
354      public boolean isDAafter(Variable v) {
355        Object _parameters = v;
356        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
357        ASTNode$State state = state();
358        if (isDAafter_Variable_values.containsKey(_parameters)) {
359          return (Boolean) isDAafter_Variable_values.get(_parameters);
360        }
361        boolean intermediate = state.INTERMEDIATE_VALUE;
362        state.INTERMEDIATE_VALUE = false;
363        int num = state.boundariesCrossed;
364        boolean isFinal = this.is$Final();
365        boolean isDAafter_Variable_value = isDAafterTrue(v) && isDAafterFalse(v);
366        if (isFinal && num == state().boundariesCrossed) {
367          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
368        } else {
369        }
370        state.INTERMEDIATE_VALUE |= intermediate;
371    
372        return isDAafter_Variable_value;
373      }
374      /**
375       * @attribute syn
376       * @aspect DU
377       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:791
378       */
379      @ASTNodeAnnotation.Attribute
380      public boolean isDUafterTrue(Variable v) {
381        boolean isDUafterTrue_Variable_value = getLeftOperand().isDUafterTrue(v) && getRightOperand().isDUafterTrue(v);
382    
383        return isDUafterTrue_Variable_value;
384      }
385      /**
386       * @attribute syn
387       * @aspect DU
388       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:792
389       */
390      @ASTNodeAnnotation.Attribute
391      public boolean isDUafterFalse(Variable v) {
392        boolean isDUafterFalse_Variable_value = getRightOperand().isDUafterFalse(v);
393    
394        return isDUafterFalse_Variable_value;
395      }
396      /**
397       * @apilevel internal
398       */
399      protected java.util.Map isDUafter_Variable_values;
400      /**
401       * @apilevel internal
402       */
403      private void isDUafter_Variable_reset() {
404        isDUafter_Variable_values = null;
405      }
406      /**
407       * @attribute syn
408       * @aspect DU
409       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:788
410       */
411      @ASTNodeAnnotation.Attribute
412      public boolean isDUafter(Variable v) {
413        Object _parameters = v;
414        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
415        ASTNode$State state = state();
416        if (isDUafter_Variable_values.containsKey(_parameters)) {
417          return (Boolean) isDUafter_Variable_values.get(_parameters);
418        }
419        boolean intermediate = state.INTERMEDIATE_VALUE;
420        state.INTERMEDIATE_VALUE = false;
421        int num = state.boundariesCrossed;
422        boolean isFinal = this.is$Final();
423        boolean isDUafter_Variable_value = isDUafterTrue(v) && isDUafterFalse(v);
424        if (isFinal && num == state().boundariesCrossed) {
425          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
426        } else {
427        }
428        state.INTERMEDIATE_VALUE |= intermediate;
429    
430        return isDUafter_Variable_value;
431      }
432      /** The operator string used for pretty printing this expression. 
433       * @attribute syn
434       * @aspect PrettyPrintUtil
435       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:270
436       */
437      @ASTNodeAnnotation.Attribute
438      public String printOp() {
439        String printOp_value = "||";
440    
441        return printOp_value;
442      }
443      /**
444       * @attribute syn
445       * @aspect CreateBCode
446       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1022
447       */
448      @ASTNodeAnnotation.Attribute
449      public boolean canBeTrue() {
450        boolean canBeTrue_value = getLeftOperand().canBeTrue() || getRightOperand().canBeTrue();
451    
452        return canBeTrue_value;
453      }
454      /**
455       * @attribute syn
456       * @aspect CreateBCode
457       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1034
458       */
459      @ASTNodeAnnotation.Attribute
460      public boolean canBeFalse() {
461        boolean canBeFalse_value = getLeftOperand().canBeFalse() && getRightOperand().canBeFalse();
462    
463        return canBeFalse_value;
464      }
465      /**
466       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
467       * @apilevel internal
468       */
469      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
470        if (caller == getRightOperandNoTransform()) {
471          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:416
472          return getLeftOperand().isDAafterFalse(v);
473        }
474        else if (caller == getLeftOperandNoTransform()) {
475          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:415
476          return isDAbefore(v);
477        }
478        else {
479          return super.Define_isDAbefore(caller, child, v);
480        }
481      }
482      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
483        return true;
484      }
485      /**
486       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
487       * @apilevel internal
488       */
489      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
490        if (caller == getRightOperandNoTransform()) {
491          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:907
492          return getLeftOperand().isDUafterFalse(v);
493        }
494        else if (caller == getLeftOperandNoTransform()) {
495          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:906
496          return isDUbefore(v);
497        }
498        else {
499          return super.Define_isDUbefore(caller, child, v);
500        }
501      }
502      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
503        return true;
504      }
505      /**
506       * @apilevel internal
507       */
508      public ASTNode rewriteTo() {
509        return super.rewriteTo();
510      }
511    }