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:147
027     * @production Binary : {@link Expr} ::= <span class="component">LeftOperand:{@link Expr}</span> <span class="component">RightOperand:{@link Expr}</span>;
028    
029     */
030    public abstract class Binary extends Expr implements Cloneable {
031      /**
032       * @aspect Java4PrettyPrint
033       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:187
034       */
035      public void prettyPrint(PrettyPrinter out) {
036        out.print(getLeftOperand());
037        out.print(" ");
038        out.print(printOp());
039        out.print(" ");
040        out.print(getRightOperand());
041      }
042      /**
043       * @aspect CreateBCode
044       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:965
045       */
046      public void createBCode(CodeGeneration gen) {
047        getLeftOperand().createBCode(gen);
048        getLeftOperand().type().emitCastTo(gen, type()); // Binary numeric promotion
049        getRightOperand().createBCode(gen);
050        getRightOperand().type().emitCastTo(gen, type()); // Binary numeric promotion
051        emitOperation(gen);
052      }
053      /**
054       * @aspect CreateBCode
055       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:973
056       */
057      public void emitShiftExpr(CodeGeneration gen) {
058        getLeftOperand().createBCode(gen);
059        getLeftOperand().type().emitCastTo(gen, type()); // Binary numeric promotion
060        getRightOperand().createBCode(gen);
061        getRightOperand().type().emitCastTo(gen, typeInt());
062        emitOperation(gen);
063      }
064      /**
065       * @declaredat ASTNode:1
066       */
067      public Binary() {
068        super();
069      }
070      /**
071       * Initializes the child array to the correct size.
072       * Initializes List and Opt nta children.
073       * @apilevel internal
074       * @ast method
075       * @declaredat ASTNode:10
076       */
077      public void init$Children() {
078        children = new ASTNode[2];
079      }
080      /**
081       * @declaredat ASTNode:13
082       */
083      public Binary(Expr p0, Expr p1) {
084        setChild(p0, 0);
085        setChild(p1, 1);
086      }
087      /**
088       * @apilevel low-level
089       * @declaredat ASTNode:20
090       */
091      protected int numChildren() {
092        return 2;
093      }
094      /**
095       * @apilevel internal
096       * @declaredat ASTNode:26
097       */
098      public boolean mayHaveRewrite() {
099        return false;
100      }
101      /**
102       * @apilevel internal
103       * @declaredat ASTNode:32
104       */
105      public void flushAttrCache() {
106        super.flushAttrCache();
107        isConstant_reset();
108        isDAafterTrue_Variable_reset();
109        isDAafterFalse_Variable_reset();
110        isDAafter_Variable_reset();
111        isDUafter_Variable_reset();
112        isDUbefore_Variable_reset();
113      }
114      /**
115       * @apilevel internal
116       * @declaredat ASTNode:44
117       */
118      public void flushCollectionCache() {
119        super.flushCollectionCache();
120      }
121      /**
122       * @apilevel internal
123       * @declaredat ASTNode:50
124       */
125      public void flushRewriteCache() {
126        super.flushRewriteCache();
127      }
128      /**
129       * @apilevel internal
130       * @declaredat ASTNode:56
131       */
132      public Binary clone() throws CloneNotSupportedException {
133        Binary node = (Binary) super.clone();
134        return node;
135      }
136      /**
137       * Create a deep copy of the AST subtree at this node.
138       * The copy is dangling, i.e. has no parent.
139       * @return dangling copy of the subtree at this node
140       * @apilevel low-level
141       * @deprecated Please use treeCopy or treeCopyNoTransform instead
142       * @declaredat ASTNode:67
143       */
144      @Deprecated
145      public abstract Binary fullCopy();
146      /**
147       * Create a deep copy of the AST subtree at this node.
148       * The copy is dangling, i.e. has no parent.
149       * @return dangling copy of the subtree at this node
150       * @apilevel low-level
151       * @declaredat ASTNode:75
152       */
153      public abstract Binary treeCopyNoTransform();
154      /**
155       * Create a deep copy of the AST subtree at this node.
156       * The subtree of this node is traversed to trigger rewrites before copy.
157       * The copy is dangling, i.e. has no parent.
158       * @return dangling copy of the subtree at this node
159       * @apilevel low-level
160       * @declaredat ASTNode:83
161       */
162      public abstract Binary treeCopy();
163      /**
164       * Replaces the LeftOperand child.
165       * @param node The new node to replace the LeftOperand child.
166       * @apilevel high-level
167       */
168      public void setLeftOperand(Expr node) {
169        setChild(node, 0);
170      }
171      /**
172       * Retrieves the LeftOperand child.
173       * @return The current node used as the LeftOperand child.
174       * @apilevel high-level
175       */
176      @ASTNodeAnnotation.Child(name="LeftOperand")
177      public Expr getLeftOperand() {
178        return (Expr) getChild(0);
179      }
180      /**
181       * Retrieves the LeftOperand child.
182       * <p><em>This method does not invoke AST transformations.</em></p>
183       * @return The current node used as the LeftOperand child.
184       * @apilevel low-level
185       */
186      public Expr getLeftOperandNoTransform() {
187        return (Expr) getChildNoTransform(0);
188      }
189      /**
190       * Replaces the RightOperand child.
191       * @param node The new node to replace the RightOperand child.
192       * @apilevel high-level
193       */
194      public void setRightOperand(Expr node) {
195        setChild(node, 1);
196      }
197      /**
198       * Retrieves the RightOperand child.
199       * @return The current node used as the RightOperand child.
200       * @apilevel high-level
201       */
202      @ASTNodeAnnotation.Child(name="RightOperand")
203      public Expr getRightOperand() {
204        return (Expr) getChild(1);
205      }
206      /**
207       * Retrieves the RightOperand child.
208       * <p><em>This method does not invoke AST transformations.</em></p>
209       * @return The current node used as the RightOperand child.
210       * @apilevel low-level
211       */
212      public Expr getRightOperandNoTransform() {
213        return (Expr) getChildNoTransform(1);
214      }
215      /**
216       * @aspect ConstantExpression
217       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:298
218       */
219      private TypeDecl refined_ConstantExpression_Binary_binaryNumericPromotedType()
220    {
221        TypeDecl leftType = left().type();
222        TypeDecl rightType = right().type();
223        if (leftType.isString()) {
224          return leftType;
225        }
226        if (rightType.isString()) {
227          return rightType;
228        }
229        if (leftType.isNumericType() && rightType.isNumericType()) {
230          return leftType.binaryNumericPromotion(rightType);
231        }
232        if (leftType.isBoolean() && rightType.isBoolean()) {
233          return leftType;
234        }
235        return unknownType();
236      }
237      /** The operator string used for pretty printing this expression. 
238       * @attribute syn
239       * @aspect PrettyPrintUtil
240       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:270
241       */
242      @ASTNodeAnnotation.Attribute
243      public abstract String printOp();
244      /**
245       * @apilevel internal
246       */
247      protected int isConstant_visited = -1;
248      /**
249       * @apilevel internal
250       */
251      private void isConstant_reset() {
252        isConstant_computed = false;
253        isConstant_initialized = false;
254        isConstant_visited = -1;
255      }
256      /**
257       * @apilevel internal
258       */
259      protected boolean isConstant_computed = false;
260      /**
261       * @apilevel internal
262       */
263      protected boolean isConstant_initialized = false;
264      /**
265       * @apilevel internal
266       */
267      protected boolean isConstant_value;
268      @ASTNodeAnnotation.Attribute
269      public boolean isConstant() {
270        if (isConstant_computed) {
271          return isConstant_value;
272        }
273        ASTNode$State state = state();
274        boolean new_isConstant_value;
275        if (!isConstant_initialized) {
276          isConstant_initialized = true;
277          isConstant_value = false;
278        }
279        if (!state.IN_CIRCLE) {
280          state.IN_CIRCLE = true;
281          int num = state.boundariesCrossed;
282          boolean isFinal = this.is$Final();
283          do {
284            isConstant_visited = state.CIRCLE_INDEX;
285            state.CHANGE = false;
286            new_isConstant_value = getLeftOperand().isConstant() && getRightOperand().isConstant();
287            if (new_isConstant_value != isConstant_value) {
288              state.CHANGE = true;
289            }
290            isConstant_value = new_isConstant_value;
291            state.CIRCLE_INDEX++;
292          } while (state.CHANGE);
293          if (isFinal && num == state().boundariesCrossed) {
294            isConstant_computed = true;
295          } else {
296            state.RESET_CYCLE = true;
297            boolean $tmp = getLeftOperand().isConstant() && getRightOperand().isConstant();
298            state.RESET_CYCLE = false;
299            isConstant_computed = false;
300            isConstant_initialized = false;
301          }
302          state.IN_CIRCLE = false;
303          state.INTERMEDIATE_VALUE = false;
304          return isConstant_value;
305        }
306        if (isConstant_visited != state.CIRCLE_INDEX) {
307          isConstant_visited = state.CIRCLE_INDEX;
308          if (state.RESET_CYCLE) {
309            isConstant_computed = false;
310            isConstant_initialized = false;
311            isConstant_visited = -1;
312            return isConstant_value;
313          }
314          new_isConstant_value = getLeftOperand().isConstant() && getRightOperand().isConstant();
315          if (new_isConstant_value != isConstant_value) {
316            state.CHANGE = true;
317          }
318          isConstant_value = new_isConstant_value;
319          state.INTERMEDIATE_VALUE = true;
320          return isConstant_value;
321        }
322        state.INTERMEDIATE_VALUE = true;
323        return isConstant_value;
324      }
325      /**
326       * @attribute syn
327       * @aspect ConstantExpression
328       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:296
329       */
330      @ASTNodeAnnotation.Attribute
331      public Expr left() {
332        Expr left_value = getLeftOperand();
333    
334        return left_value;
335      }
336      /**
337       * @attribute syn
338       * @aspect ConstantExpression
339       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:297
340       */
341      @ASTNodeAnnotation.Attribute
342      public Expr right() {
343        Expr right_value = getRightOperand();
344    
345        return right_value;
346      }
347      /**
348       * @attribute syn
349       * @aspect ConstantExpression
350       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:298
351       */
352      @ASTNodeAnnotation.Attribute
353      public TypeDecl binaryNumericPromotedType() {
354        {
355            TypeDecl leftType = left().type();
356            TypeDecl rightType = right().type();
357            if (leftType.isBoolean() && rightType.isBoolean()) {
358              return leftType.isReferenceType() ? leftType.unboxed() : leftType;
359            }
360            return refined_ConstantExpression_Binary_binaryNumericPromotedType();
361          }
362      }
363      /**
364       * @apilevel internal
365       */
366      protected java.util.Map isDAafterTrue_Variable_values;
367      /**
368       * @apilevel internal
369       */
370      private void isDAafterTrue_Variable_reset() {
371        isDAafterTrue_Variable_values = null;
372      }
373      /**
374       * @attribute syn
375       * @aspect DA
376       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:442
377       */
378      @ASTNodeAnnotation.Attribute
379      public boolean isDAafterTrue(Variable v) {
380        Object _parameters = v;
381        if (isDAafterTrue_Variable_values == null) isDAafterTrue_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
382        ASTNode$State state = state();
383        if (isDAafterTrue_Variable_values.containsKey(_parameters)) {
384          return (Boolean) isDAafterTrue_Variable_values.get(_parameters);
385        }
386        boolean intermediate = state.INTERMEDIATE_VALUE;
387        state.INTERMEDIATE_VALUE = false;
388        int num = state.boundariesCrossed;
389        boolean isFinal = this.is$Final();
390        boolean isDAafterTrue_Variable_value = isFalse() || getRightOperand().isDAafter(v);
391        if (isFinal && num == state().boundariesCrossed) {
392          isDAafterTrue_Variable_values.put(_parameters, isDAafterTrue_Variable_value);
393        } else {
394        }
395        state.INTERMEDIATE_VALUE |= intermediate;
396    
397        return isDAafterTrue_Variable_value;
398      }
399      /**
400       * @apilevel internal
401       */
402      protected java.util.Map isDAafterFalse_Variable_values;
403      /**
404       * @apilevel internal
405       */
406      private void isDAafterFalse_Variable_reset() {
407        isDAafterFalse_Variable_values = null;
408      }
409      /**
410       * @attribute syn
411       * @aspect DA
412       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:443
413       */
414      @ASTNodeAnnotation.Attribute
415      public boolean isDAafterFalse(Variable v) {
416        Object _parameters = v;
417        if (isDAafterFalse_Variable_values == null) isDAafterFalse_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
418        ASTNode$State state = state();
419        if (isDAafterFalse_Variable_values.containsKey(_parameters)) {
420          return (Boolean) isDAafterFalse_Variable_values.get(_parameters);
421        }
422        boolean intermediate = state.INTERMEDIATE_VALUE;
423        state.INTERMEDIATE_VALUE = false;
424        int num = state.boundariesCrossed;
425        boolean isFinal = this.is$Final();
426        boolean isDAafterFalse_Variable_value = isTrue() || getRightOperand().isDAafter(v);
427        if (isFinal && num == state().boundariesCrossed) {
428          isDAafterFalse_Variable_values.put(_parameters, isDAafterFalse_Variable_value);
429        } else {
430        }
431        state.INTERMEDIATE_VALUE |= intermediate;
432    
433        return isDAafterFalse_Variable_value;
434      }
435      /**
436       * @apilevel internal
437       */
438      protected java.util.Map isDAafter_Variable_values;
439      /**
440       * @apilevel internal
441       */
442      private void isDAafter_Variable_reset() {
443        isDAafter_Variable_values = null;
444      }
445      /**
446       * @attribute syn
447       * @aspect DA
448       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:261
449       */
450      @ASTNodeAnnotation.Attribute
451      public boolean isDAafter(Variable v) {
452        Object _parameters = v;
453        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
454        ASTNode$State state = state();
455        if (isDAafter_Variable_values.containsKey(_parameters)) {
456          return (Boolean) isDAafter_Variable_values.get(_parameters);
457        }
458        boolean intermediate = state.INTERMEDIATE_VALUE;
459        state.INTERMEDIATE_VALUE = false;
460        int num = state.boundariesCrossed;
461        boolean isFinal = this.is$Final();
462        boolean isDAafter_Variable_value = getRightOperand().isDAafter(v);
463        if (isFinal && num == state().boundariesCrossed) {
464          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
465        } else {
466        }
467        state.INTERMEDIATE_VALUE |= intermediate;
468    
469        return isDAafter_Variable_value;
470      }
471      /**
472       * @apilevel internal
473       */
474      protected java.util.Map isDUafter_Variable_values;
475      /**
476       * @apilevel internal
477       */
478      private void isDUafter_Variable_reset() {
479        isDUafter_Variable_values = null;
480      }
481      /**
482       * @attribute syn
483       * @aspect DU
484       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:788
485       */
486      @ASTNodeAnnotation.Attribute
487      public boolean isDUafter(Variable v) {
488        Object _parameters = v;
489        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
490        ASTNode$State state = state();
491        if (isDUafter_Variable_values.containsKey(_parameters)) {
492          return (Boolean) isDUafter_Variable_values.get(_parameters);
493        }
494        boolean intermediate = state.INTERMEDIATE_VALUE;
495        state.INTERMEDIATE_VALUE = false;
496        int num = state.boundariesCrossed;
497        boolean isFinal = this.is$Final();
498        boolean isDUafter_Variable_value = getRightOperand().isDUafter(v);
499        if (isFinal && num == state().boundariesCrossed) {
500          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
501        } else {
502        }
503        state.INTERMEDIATE_VALUE |= intermediate;
504    
505        return isDUafter_Variable_value;
506      }
507      /**
508       * @attribute syn
509       * @aspect PreciseRethrow
510       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149
511       */
512      @ASTNodeAnnotation.Attribute
513      public boolean modifiedInScope(Variable var) {
514        boolean modifiedInScope_Variable_value = getLeftOperand().modifiedInScope(var) || getRightOperand().modifiedInScope(var);
515    
516        return modifiedInScope_Variable_value;
517      }
518      /**
519       * @attribute inh
520       * @aspect DU
521       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:785
522       */
523      /**
524       * @attribute inh
525       * @aspect DU
526       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:785
527       */
528      @ASTNodeAnnotation.Attribute
529      public boolean isDUbefore(Variable v) {
530        Object _parameters = v;
531        if (isDUbefore_Variable_values == null) isDUbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
532        ASTNode$State state = state();
533        if (isDUbefore_Variable_values.containsKey(_parameters)) {
534          return (Boolean) isDUbefore_Variable_values.get(_parameters);
535        }
536        boolean intermediate = state.INTERMEDIATE_VALUE;
537        state.INTERMEDIATE_VALUE = false;
538        int num = state.boundariesCrossed;
539        boolean isFinal = this.is$Final();
540        boolean isDUbefore_Variable_value = getParent().Define_isDUbefore(this, null, v);
541        if (isFinal && num == state().boundariesCrossed) {
542          isDUbefore_Variable_values.put(_parameters, isDUbefore_Variable_value);
543        } else {
544        }
545        state.INTERMEDIATE_VALUE |= intermediate;
546    
547        return isDUbefore_Variable_value;
548      }
549      /**
550       * @apilevel internal
551       */
552      protected java.util.Map isDUbefore_Variable_values;
553      /**
554       * @apilevel internal
555       */
556      private void isDUbefore_Variable_reset() {
557        isDUbefore_Variable_values = null;
558      }
559      /**
560       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
561       * @apilevel internal
562       */
563      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
564        if (caller == getRightOperandNoTransform()) {
565          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:446
566          return getLeftOperand().isDAafter(v);
567        }
568        else {
569          return getParent().Define_isDAbefore(this, caller, v);
570        }
571      }
572      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
573        return true;
574      }
575      /**
576       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
577       * @apilevel internal
578       */
579      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
580        if (caller == getRightOperandNoTransform()) {
581          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:951
582          return getLeftOperand().isDUafter(v);
583        }
584        else {
585          return getParent().Define_isDUbefore(this, caller, v);
586        }
587      }
588      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
589        return true;
590      }
591      /**
592       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196
593       * @apilevel internal
594       */
595      public boolean Define_assignmentContext(ASTNode caller, ASTNode child) {
596        int childIndex = this.getIndexOfChild(caller);
597        return false;
598      }
599      protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) {
600        return true;
601      }
602      /**
603       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197
604       * @apilevel internal
605       */
606      public boolean Define_invocationContext(ASTNode caller, ASTNode child) {
607        int childIndex = this.getIndexOfChild(caller);
608        return false;
609      }
610      protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) {
611        return true;
612      }
613      /**
614       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198
615       * @apilevel internal
616       */
617      public boolean Define_castContext(ASTNode caller, ASTNode child) {
618        int childIndex = this.getIndexOfChild(caller);
619        return false;
620      }
621      protected boolean canDefine_castContext(ASTNode caller, ASTNode child) {
622        return true;
623      }
624      /**
625       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199
626       * @apilevel internal
627       */
628      public boolean Define_stringContext(ASTNode caller, ASTNode child) {
629        int childIndex = this.getIndexOfChild(caller);
630        return false;
631      }
632      protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) {
633        return true;
634      }
635      /**
636       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200
637       * @apilevel internal
638       */
639      public boolean Define_numericContext(ASTNode caller, ASTNode child) {
640        int childIndex = this.getIndexOfChild(caller);
641        return false;
642      }
643      protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) {
644        return true;
645      }
646      /**
647       * @apilevel internal
648       */
649      public ASTNode rewriteTo() {
650        return super.rewriteTo();
651      }
652    }