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 ParExpr : {@link PrimaryExpr} ::= <span class="component">{@link Expr}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:131
017     */
018    public class ParExpr extends PrimaryExpr 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 ParExpr clone() throws CloneNotSupportedException {
034        ParExpr node = (ParExpr)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     * @apilevel internal
043     */
044      @SuppressWarnings({"unchecked", "cast"})
045    public ParExpr copy() {
046      
047      try {
048        ParExpr node = (ParExpr) clone();
049        node.parent = null;
050        if(children != null)
051          node.children = (ASTNode[]) children.clone();
052        
053        return node;
054      } catch (CloneNotSupportedException e) {
055        throw new Error("Error: clone not supported for " + getClass().getName());
056      }
057      
058    }/**
059     * Create a deep copy of the AST subtree at this node.
060     * The copy is dangling, i.e. has no parent.
061     * @return dangling copy of the subtree at this node
062     * @apilevel low-level
063     */
064      @SuppressWarnings({"unchecked", "cast"})
065    public ParExpr fullCopy() {
066      
067      ParExpr tree = (ParExpr) copy();
068      if (children != null) {
069        for (int i = 0; i < children.length; ++i) {
070          
071          ASTNode child = (ASTNode) children[i];
072          if(child != null) {
073            child = child.fullCopy();
074            tree.setChild(child, i);
075          }
076        }
077      }
078      return tree;
079      
080    }  /**
081       * @ast method 
082       * @aspect PrettyPrint
083       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:321
084       */
085      public void toString(StringBuffer s) {
086        s.append("(");
087        getExpr().toString(s);
088        s.append(")");
089      }
090      /**
091       * @ast method 
092       * @aspect TypeCheck
093       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:263
094       */
095      public void typeCheck() {
096        if(getExpr().isTypeAccess())
097          error("" + getExpr() + " is a type and may not be used in parenthesized expression");
098      }
099      /**
100       * @ast method 
101       * @aspect CreateBCode
102       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1082
103       */
104      public void emitEvalBranch(CodeGeneration gen)     { getExpr().emitEvalBranch(gen); }
105      /**
106       * @ast method 
107       * 
108       */
109      public ParExpr() {
110        super();
111    
112    
113      }
114      /**
115       * Initializes the child array to the correct size.
116       * Initializes List and Opt nta children.
117       * @apilevel internal
118       * @ast method
119       * @ast method 
120       * 
121       */
122      public void init$Children() {
123        children = new ASTNode[1];
124      }
125      /**
126       * @ast method 
127       * 
128       */
129      public ParExpr(Expr p0) {
130        setChild(p0, 0);
131      }
132      /**
133       * @apilevel low-level
134       * @ast method 
135       * 
136       */
137      protected int numChildren() {
138        return 1;
139      }
140      /**
141       * @apilevel internal
142       * @ast method 
143       * 
144       */
145      public boolean mayHaveRewrite() {
146        return false;
147      }
148      /**
149       * Replaces the Expr child.
150       * @param node The new node to replace the Expr child.
151       * @apilevel high-level
152       * @ast method 
153       * 
154       */
155      public void setExpr(Expr node) {
156        setChild(node, 0);
157      }
158      /**
159       * Retrieves the Expr child.
160       * @return The current node used as the Expr child.
161       * @apilevel high-level
162       * @ast method 
163       * 
164       */
165      public Expr getExpr() {
166        return (Expr)getChild(0);
167      }
168      /**
169       * Retrieves the Expr child.
170       * <p><em>This method does not invoke AST transformations.</em></p>
171       * @return The current node used as the Expr child.
172       * @apilevel low-level
173       * @ast method 
174       * 
175       */
176      public Expr getExprNoTransform() {
177        return (Expr)getChildNoTransform(0);
178      }
179      /**
180       * @attribute syn
181       * @aspect ConstantExpression
182       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:91
183       */
184      public Constant constant() {
185        ASTNode$State state = state();
186        try {  return getExpr().constant();  }
187        finally {
188        }
189      }
190      /**
191       * @attribute syn
192       * @aspect ConstantExpression
193       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:336
194       */
195      public boolean isConstant() {
196        ASTNode$State state = state();
197        try {  return getExpr().isConstant();  }
198        finally {
199        }
200      }
201      /**
202       * @attribute syn
203       * @aspect DefiniteAssignment
204       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:58
205       */
206      public Variable varDecl() {
207        ASTNode$State state = state();
208        try {  return getExpr().varDecl();  }
209        finally {
210        }
211      }
212      /*eq Stmt.isDAafter(Variable v) {
213        //System.out.println("### isDAafter reached in " + getClass().getName());
214        //throw new NullPointerException();
215        throw new Error("Can not compute isDAafter for " + getClass().getName() + " at " + errorPrefix());
216      }* @attribute syn
217       * @aspect DA
218       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:332
219       */
220      public boolean isDAafterTrue(Variable v) {
221        ASTNode$State state = state();
222        try {  return getExpr().isDAafterTrue(v) || isFalse();  }
223        finally {
224        }
225      }
226      /**
227       * @attribute syn
228       * @aspect DA
229       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:333
230       */
231      public boolean isDAafterFalse(Variable v) {
232        ASTNode$State state = state();
233        try {  return getExpr().isDAafterFalse(v) || isTrue();  }
234        finally {
235        }
236      }
237      /**
238       * @attribute syn
239       * @aspect DA
240       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:235
241       */
242      public boolean isDAafter(Variable v) {
243        ASTNode$State state = state();
244        try {  return getExpr().isDAafter(v);  }
245        finally {
246        }
247      }
248      /**
249       * @attribute syn
250       * @aspect DU
251       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:702
252       */
253      public boolean isDUafterTrue(Variable v) {
254        ASTNode$State state = state();
255        try {  return getExpr().isDUafterTrue(v);  }
256        finally {
257        }
258      }
259      /**
260       * @attribute syn
261       * @aspect DU
262       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:703
263       */
264      public boolean isDUafterFalse(Variable v) {
265        ASTNode$State state = state();
266        try {  return getExpr().isDUafterFalse(v);  }
267        finally {
268        }
269      }
270      /**
271       * @attribute syn
272       * @aspect DU
273       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:694
274       */
275      public boolean isDUafter(Variable v) {
276        ASTNode$State state = state();
277        try {  return getExpr().isDUafter(v);  }
278        finally {
279        }
280      }
281      /**
282       * @attribute syn
283       * @aspect AccessTypes
284       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:25
285       */
286      public boolean isSuperAccess() {
287        ASTNode$State state = state();
288        try {  return getExpr().isSuperAccess();  }
289        finally {
290        }
291      }
292      /**
293       * @attribute syn
294       * @aspect AccessTypes
295       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:31
296       */
297      public boolean isThisAccess() {
298        ASTNode$State state = state();
299        try {  return getExpr().isThisAccess();  }
300        finally {
301        }
302      }
303      /**
304       * @apilevel internal
305       */
306      protected boolean type_computed = false;
307      /**
308       * @apilevel internal
309       */
310      protected TypeDecl type_value;
311      /**
312       * @attribute syn
313       * @aspect TypeAnalysis
314       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:309
315       */
316      @SuppressWarnings({"unchecked", "cast"})
317      public TypeDecl type() {
318        if(type_computed) {
319          return type_value;
320        }
321          ASTNode$State state = state();
322      int num = state.boundariesCrossed;
323      boolean isFinal = this.is$Final();
324        type_value = type_compute();
325      if(isFinal && num == state().boundariesCrossed){ type_computed = true; }
326            return type_value;
327      }
328      /**
329       * @apilevel internal
330       */
331      private TypeDecl type_compute() {  return getExpr().isTypeAccess() ? unknownType() : getExpr().type();  }
332      /**
333       * @attribute syn
334       * @aspect TypeCheck
335       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:15
336       */
337      public boolean isVariable() {
338        ASTNode$State state = state();
339        try {  return getExpr().isVariable();  }
340        finally {
341        }
342      }
343      /**
344       * @attribute syn
345       * @aspect TypeHierarchyCheck
346       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeHierarchyCheck.jrag:150
347       */
348      public boolean staticContextQualifier() {
349        ASTNode$State state = state();
350        try {  return getExpr().staticContextQualifier();  }
351        finally {
352        }
353      }
354      /**
355       * @attribute syn
356       * @aspect CreateBCode
357       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:219
358       */
359      public boolean needsPop() {
360        ASTNode$State state = state();
361        try {  return getExpr().needsPop();  }
362        finally {
363        }
364      }
365      /**
366       * @attribute syn
367       * @aspect CreateBCode
368       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:231
369       */
370      public boolean isVarAccessWithAccessor() {
371        ASTNode$State state = state();
372        try {  return getExpr().isVarAccessWithAccessor();  }
373        finally {
374        }
375      }
376      /**
377       * @attribute syn
378       * @aspect CreateBCode
379       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:946
380       */
381      public boolean definesLabel() {
382        ASTNode$State state = state();
383        try {  return getParent().definesLabel();  }
384        finally {
385        }
386      }
387      /**
388       * @attribute syn
389       * @aspect CreateBCode
390       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1007
391       */
392      public boolean canBeTrue() {
393        ASTNode$State state = state();
394        try {  return getExpr().canBeTrue();  }
395        finally {
396        }
397      }
398      /**
399       * @attribute syn
400       * @aspect CreateBCode
401       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1017
402       */
403      public boolean canBeFalse() {
404        ASTNode$State state = state();
405        try {  return getExpr().canBeFalse();  }
406        finally {
407        }
408      }
409      /**
410       * @apilevel internal
411       */
412      public ASTNode rewriteTo() {
413        return super.rewriteTo();
414      }
415    }