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 AssignExpr : {@link Expr} ::= <span class="component">Dest:{@link Expr}</span> <span class="component">Source:{@link Expr}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:106
017     */
018    public abstract class AssignExpr 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 AssignExpr clone() throws CloneNotSupportedException {
034        AssignExpr node = (AssignExpr)super.clone();
035        node.type_computed = false;
036        node.type_value = null;
037        node.in$Circle(false);
038        node.is$Final(false);
039        return node;
040      }
041      /**
042       * @ast method 
043       * @aspect DA
044       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:463
045       */
046      protected boolean checkDUeverywhere(Variable v) {
047        if(getDest().isVariable() && getDest().varDecl() == v)
048          if(!getSource().isDAafter(v))
049            return false;
050        return super.checkDUeverywhere(v);
051      }
052      /**
053       * @ast method 
054       * @aspect NodeConstructors
055       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NodeConstructors.jrag:94
056       */
057      public static Stmt asStmt(Expr left, Expr right) {
058        return new ExprStmt(new AssignSimpleExpr(left, right));
059      }
060      /**
061       * @ast method 
062       * @aspect PrettyPrint
063       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:241
064       */
065      public void toString(StringBuffer s) {
066        getDest().toString(s);
067        s.append(printOp());
068        getSource().toString(s);
069      }
070      /**
071       * @ast method 
072       * @aspect TypeCheck
073       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:52
074       */
075      public void typeCheck() {
076        if(!getDest().isVariable())
077          error("left hand side is not a variable");
078        else {
079          TypeDecl source = sourceType();
080          TypeDecl dest = getDest().type();
081          if(getSource().type().isPrimitive() && getDest().type().isPrimitive())
082            return;
083          error("can not assign " + getDest() + " of type " + getDest().type().typeName() +
084                " a value of type " + sourceType().typeName());
085        }
086      }
087      /**
088       * @ast method 
089       * @aspect CreateBCode
090       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:330
091       */
092      public void emitShiftExpr(CodeGeneration gen) {
093        TypeDecl dest = getDest().type();
094        TypeDecl source = getSource().type();
095        TypeDecl type = dest.unaryNumericPromotion();
096        getDest().createAssignLoadDest(gen);
097        dest.emitCastTo(gen, type);
098        getSource().createBCode(gen);
099        source.emitCastTo(gen, typeInt());
100        createAssignOp(gen, type);
101        type.emitCastTo(gen, dest);
102        if(needsPush()) {
103          getDest().createPushAssignmentResult(gen);
104        }
105        getDest().emitStore(gen);
106      }
107      /**
108       * @ast method 
109       * @aspect CreateBCode
110       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:419
111       */
112      public void createAssignOp(CodeGeneration gen, TypeDecl type) {
113        throw new Error("Operation createAssignOp is not implemented for " + getClass().getName());
114      }
115      /**
116       * @ast method 
117       * 
118       */
119      public AssignExpr() {
120        super();
121    
122    
123      }
124      /**
125       * Initializes the child array to the correct size.
126       * Initializes List and Opt nta children.
127       * @apilevel internal
128       * @ast method
129       * @ast method 
130       * 
131       */
132      public void init$Children() {
133        children = new ASTNode[2];
134      }
135      /**
136       * @ast method 
137       * 
138       */
139      public AssignExpr(Expr p0, Expr p1) {
140        setChild(p0, 0);
141        setChild(p1, 1);
142      }
143      /**
144       * @apilevel low-level
145       * @ast method 
146       * 
147       */
148      protected int numChildren() {
149        return 2;
150      }
151      /**
152       * @apilevel internal
153       * @ast method 
154       * 
155       */
156      public boolean mayHaveRewrite() {
157        return false;
158      }
159      /**
160       * Replaces the Dest child.
161       * @param node The new node to replace the Dest child.
162       * @apilevel high-level
163       * @ast method 
164       * 
165       */
166      public void setDest(Expr node) {
167        setChild(node, 0);
168      }
169      /**
170       * Retrieves the Dest child.
171       * @return The current node used as the Dest child.
172       * @apilevel high-level
173       * @ast method 
174       * 
175       */
176      public Expr getDest() {
177        return (Expr)getChild(0);
178      }
179      /**
180       * Retrieves the Dest child.
181       * <p><em>This method does not invoke AST transformations.</em></p>
182       * @return The current node used as the Dest child.
183       * @apilevel low-level
184       * @ast method 
185       * 
186       */
187      public Expr getDestNoTransform() {
188        return (Expr)getChildNoTransform(0);
189      }
190      /**
191       * Replaces the Source child.
192       * @param node The new node to replace the Source child.
193       * @apilevel high-level
194       * @ast method 
195       * 
196       */
197      public void setSource(Expr node) {
198        setChild(node, 1);
199      }
200      /**
201       * Retrieves the Source child.
202       * @return The current node used as the Source child.
203       * @apilevel high-level
204       * @ast method 
205       * 
206       */
207      public Expr getSource() {
208        return (Expr)getChild(1);
209      }
210      /**
211       * Retrieves the Source child.
212       * <p><em>This method does not invoke AST transformations.</em></p>
213       * @return The current node used as the Source child.
214       * @apilevel low-level
215       * @ast method 
216       * 
217       */
218      public Expr getSourceNoTransform() {
219        return (Expr)getChildNoTransform(1);
220      }
221      /**
222       * @ast method 
223       * @aspect AutoBoxingCodegen
224       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/AutoBoxingCodegen.jrag:307
225       */
226        public void createBCode(CodeGeneration gen) {
227        TypeDecl dest = getDest().type();
228        TypeDecl source = getSource().type();
229        TypeDecl type;
230        if(dest.isNumericType() && source.isNumericType())
231          type = dest.binaryNumericPromotion(source);
232        else if(dest.isBoolean() && source.isBoolean()) {
233          type = dest.isReferenceType() ? dest.unboxed() : dest;
234        }
235        else
236          type = dest;
237        getDest().createAssignLoadDest(gen);
238        dest.emitCastTo(gen, type);
239        getSource().createBCode(gen);
240        source.emitCastTo(gen, type);
241        createAssignOp(gen, type);
242        type.emitCastTo(gen, dest);
243        if(needsPush()) {
244          getDest().createPushAssignmentResult(gen);
245        }
246        getDest().emitStore(gen);
247      }
248      /**
249       * @attribute syn
250       * @aspect DA
251       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:235
252       */
253      public boolean isDAafter(Variable v) {
254        ASTNode$State state = state();
255        try {  return (getDest().isVariable() && getDest().varDecl() == v) || getSource().isDAafter(v);  }
256        finally {
257        }
258      }
259      /*eq Stmt.isDAafter(Variable v) {
260        //System.out.println("### isDAafter reached in " + getClass().getName());
261        //throw new NullPointerException();
262        throw new Error("Can not compute isDAafter for " + getClass().getName() + " at " + errorPrefix());
263      }* @attribute syn
264       * @aspect DA
265       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:332
266       */
267      public boolean isDAafterTrue(Variable v) {
268        ASTNode$State state = state();
269        try {  return isDAafter(v) || isFalse();  }
270        finally {
271        }
272      }
273      /**
274       * @attribute syn
275       * @aspect DA
276       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:333
277       */
278      public boolean isDAafterFalse(Variable v) {
279        ASTNode$State state = state();
280        try {  return isDAafter(v) || isTrue();  }
281        finally {
282        }
283      }
284      /**
285       * @attribute syn
286       * @aspect DU
287       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:694
288       */
289      public boolean isDUafter(Variable v) {
290        ASTNode$State state = state();
291        try {  return getSource().isDUafter(v);  }
292        finally {
293        }
294      }
295      /**
296       * @attribute syn
297       * @aspect DU
298       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:702
299       */
300      public boolean isDUafterTrue(Variable v) {
301        ASTNode$State state = state();
302        try {  return isDUafter(v);  }
303        finally {
304        }
305      }
306      /**
307       * @attribute syn
308       * @aspect DU
309       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:703
310       */
311      public boolean isDUafterFalse(Variable v) {
312        ASTNode$State state = state();
313        try {  return isDUafter(v);  }
314        finally {
315        }
316      }
317      /**
318       * @attribute syn
319       * @aspect PrettyPrint
320       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:247
321       */
322      public String printOp() {
323        ASTNode$State state = state();
324        try {  return " = ";  }
325        finally {
326        }
327      }
328      /**
329       * @apilevel internal
330       */
331      protected boolean type_computed = false;
332      /**
333       * @apilevel internal
334       */
335      protected TypeDecl type_value;
336      /**
337       * @attribute syn
338       * @aspect TypeAnalysis
339       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:298
340       */
341      @SuppressWarnings({"unchecked", "cast"})
342      public TypeDecl type() {
343        if(type_computed) {
344          return type_value;
345        }
346          ASTNode$State state = state();
347      int num = state.boundariesCrossed;
348      boolean isFinal = this.is$Final();
349        type_value = type_compute();
350      if(isFinal && num == state().boundariesCrossed){ type_computed = true; }
351            return type_value;
352      }
353      /**
354       * @apilevel internal
355       */
356      private TypeDecl type_compute() {  return getDest().type();  }
357      /**
358       * @attribute syn
359       * @aspect TypeCheck
360       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:109
361       */
362      public TypeDecl sourceType() {
363        ASTNode$State state = state();
364        try {  return getSource().type().isPrimitive() ? getSource().type() : unknownType();  }
365        finally {
366        }
367      }
368      /**
369       * @attribute syn
370       * @aspect CreateBCode
371       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:219
372       */
373      public boolean needsPop() {
374        ASTNode$State state = state();
375        try {  return getDest().isVarAccessWithAccessor();  }
376        finally {
377        }
378      }
379      /**
380       * @attribute syn
381       * @aspect PreciseRethrow
382       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:111
383       */
384      public boolean modifiedInScope(Variable var) {
385        ASTNode$State state = state();
386        try {  return getDest().isVariable(var);  }
387        finally {
388        }
389      }
390      /**
391       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:19
392       * @apilevel internal
393       */
394      public boolean Define_boolean_isDest(ASTNode caller, ASTNode child) {
395        if(caller == getSourceNoTransform()) {
396          return false;
397        }
398        else if(caller == getDestNoTransform()) {
399          return true;
400        }
401        else {      return getParent().Define_boolean_isDest(this, caller);
402        }
403      }
404      /**
405       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:29
406       * @apilevel internal
407       */
408      public boolean Define_boolean_isSource(ASTNode caller, ASTNode child) {
409        if(caller == getSourceNoTransform()) {
410          return true;
411        }
412        else if(caller == getDestNoTransform()) {
413          return true;
414        }
415        else {      return getParent().Define_boolean_isSource(this, caller);
416        }
417      }
418      /**
419       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:392
420       * @apilevel internal
421       */
422      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
423        if(caller == getDestNoTransform()) {
424          return isDAbefore(v);
425        }
426        else if(caller == getSourceNoTransform()) {
427          return getDest().isDAafter(v);
428        }
429        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
430        }
431      }
432      /**
433       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:828
434       * @apilevel internal
435       */
436      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
437        if(caller == getDestNoTransform()) {
438          return isDUbefore(v);
439        }
440        else if(caller == getSourceNoTransform()) {
441          return getDest().isDUafter(v);
442        }
443        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
444        }
445      }
446      /**
447       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/SyntacticClassification.jrag:99
448       * @apilevel internal
449       */
450      public NameType Define_NameType_nameType(ASTNode caller, ASTNode child) {
451        if(caller == getDestNoTransform()) {
452          return NameType.EXPRESSION_NAME;
453        }
454        else {      return getParent().Define_NameType_nameType(this, caller);
455        }
456      }
457      /**
458       * @apilevel internal
459       */
460      public ASTNode rewriteTo() {
461        return super.rewriteTo();
462      }
463    }