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