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 Unary : {@link Expr} ::= <span class="component">Operand:{@link Expr}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:136
017     */
018    public abstract class Unary 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 Unary clone() throws CloneNotSupportedException {
034        Unary node = (Unary)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 PrettyPrint
044       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:366
045       */
046      public void toString(StringBuffer s) {
047        s.append(printPreOp());
048        getOperand().toString(s);
049        s.append(printPostOp());
050      }
051      /**
052       * @ast method 
053       * @aspect CreateBCode
054       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:835
055       */
056      public void createBCode(CodeGeneration gen) {   
057        super.createBCode(gen);
058        emitOperation(gen);
059      }
060      /**
061       * @ast method 
062       * @aspect AutoBoxingCodegen
063       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/AutoBoxingCodegen.jrag:295
064       */
065      protected void boxingGen(CodeGeneration gen) {
066        getOperand().createBCode(gen);
067        TypeDecl type = getOperand().type();
068        if(type.isReferenceType())
069          type.emitCastTo(gen, type());
070        emitOperation(gen);
071      }
072      /**
073       * @ast method 
074       * 
075       */
076      public Unary() {
077        super();
078    
079    
080      }
081      /**
082       * Initializes the child array to the correct size.
083       * Initializes List and Opt nta children.
084       * @apilevel internal
085       * @ast method
086       * @ast method 
087       * 
088       */
089      public void init$Children() {
090        children = new ASTNode[1];
091      }
092      /**
093       * @ast method 
094       * 
095       */
096      public Unary(Expr p0) {
097        setChild(p0, 0);
098      }
099      /**
100       * @apilevel low-level
101       * @ast method 
102       * 
103       */
104      protected int numChildren() {
105        return 1;
106      }
107      /**
108       * @apilevel internal
109       * @ast method 
110       * 
111       */
112      public boolean mayHaveRewrite() {
113        return false;
114      }
115      /**
116       * Replaces the Operand child.
117       * @param node The new node to replace the Operand child.
118       * @apilevel high-level
119       * @ast method 
120       * 
121       */
122      public void setOperand(Expr node) {
123        setChild(node, 0);
124      }
125      /**
126       * Retrieves the Operand child.
127       * @return The current node used as the Operand child.
128       * @apilevel high-level
129       * @ast method 
130       * 
131       */
132      public Expr getOperand() {
133        return (Expr)getChild(0);
134      }
135      /**
136       * Retrieves the Operand child.
137       * <p><em>This method does not invoke AST transformations.</em></p>
138       * @return The current node used as the Operand child.
139       * @apilevel low-level
140       * @ast method 
141       * 
142       */
143      public Expr getOperandNoTransform() {
144        return (Expr)getChildNoTransform(0);
145      }
146      /**
147       * @ast method 
148       * @aspect AutoBoxingCodegen
149       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/AutoBoxingCodegen.jrag:201
150       */
151        public void emitPostfix(CodeGeneration gen, int constant) {
152        Expr operand = getOperand();
153        while(operand instanceof ParExpr)
154          operand = ((ParExpr)operand).getExpr();
155        Access access = ((Access)operand).lastAccess();
156        access.createAssignLoadDest(gen);
157        if(needsPush())
158          access.createPushAssignmentResult(gen);
159        TypeDecl type = access.type().binaryNumericPromotion(typeInt());
160        access.type().emitCastTo(gen, type); // Added for AutoBoxing
161        type.emitPushConstant(gen, constant);
162        type.add(gen);
163        type.emitCastTo(gen, access.type());
164        access.emitStore(gen);
165      }
166      /**
167       * @ast method 
168       * @aspect AutoBoxingCodegen
169       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/AutoBoxingCodegen.jrag:219
170       */
171        public void emitPrefix(CodeGeneration gen, int constant) {
172        Expr operand = getOperand();
173        while(operand instanceof ParExpr)
174          operand = ((ParExpr)operand).getExpr();
175        Access access = ((Access)operand).lastAccess();
176        access.createAssignLoadDest(gen);
177        TypeDecl type = access.type().binaryNumericPromotion(typeInt());
178        access.type().emitCastTo(gen, type); // Added for AutoBoxing
179        type.emitPushConstant(gen, constant);
180        type.add(gen);
181        type.emitCastTo(gen, access.type());
182        if(needsPush())
183          access.createPushAssignmentResult(gen);
184        access.emitStore(gen);
185      }
186      /**
187       * @attribute syn
188       * @aspect DA
189       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:235
190       */
191      public boolean isDAafter(Variable v) {
192        ASTNode$State state = state();
193        try {  return getOperand().isDAafter(v);  }
194        finally {
195        }
196      }
197      /**
198       * @attribute syn
199       * @aspect DU
200       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:694
201       */
202      public boolean isDUafter(Variable v) {
203        ASTNode$State state = state();
204        try {  return getOperand().isDUafter(v);  }
205        finally {
206        }
207      }
208      /**
209       * @attribute syn
210       * @aspect PrettyPrint
211       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:372
212       */
213      public String printPostOp() {
214        ASTNode$State state = state();
215        try {  return "";  }
216        finally {
217        }
218      }
219      /**
220       * @attribute syn
221       * @aspect PrettyPrint
222       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:376
223       */
224      public String printPreOp() {
225        ASTNode$State state = state();
226        try {  return "";  }
227        finally {
228        }
229      }
230      /**
231       * @apilevel internal
232       */
233      protected boolean type_computed = false;
234      /**
235       * @apilevel internal
236       */
237      protected TypeDecl type_value;
238      /**
239       * @attribute syn
240       * @aspect TypeAnalysis
241       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:314
242       */
243      @SuppressWarnings({"unchecked", "cast"})
244      public TypeDecl type() {
245        if(type_computed) {
246          return type_value;
247        }
248          ASTNode$State state = state();
249      int num = state.boundariesCrossed;
250      boolean isFinal = this.is$Final();
251        type_value = type_compute();
252      if(isFinal && num == state().boundariesCrossed){ type_computed = true; }
253            return type_value;
254      }
255      /**
256       * @apilevel internal
257       */
258      private TypeDecl type_compute() {  return getOperand().type();  }
259      /**
260       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:44
261       * @apilevel internal
262       */
263      public boolean Define_boolean_isSource(ASTNode caller, ASTNode child) {
264        if(caller == getOperandNoTransform()) {
265          return true;
266        }
267        else {      return getParent().Define_boolean_isSource(this, caller);
268        }
269      }
270      /**
271       * @apilevel internal
272       */
273      public ASTNode rewriteTo() {
274        return super.rewriteTo();
275      }
276    }