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 ThrowStmt : {@link Stmt} ::= <span class="component">{@link Expr}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:215
017     */
018    public class ThrowStmt extends Stmt 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 ThrowStmt clone() throws CloneNotSupportedException {
034        ThrowStmt node = (ThrowStmt)super.clone();
035        node.isDAafter_Variable_values = null;
036        node.isDUafter_Variable_values = null;
037        node.canCompleteNormally_computed = false;
038        node.typeNullPointerException_computed = false;
039        node.typeNullPointerException_value = null;
040        node.handlesException_TypeDecl_values = null;
041        node.typeThrowable_computed = false;
042        node.typeThrowable_value = null;
043        node.typeNull_computed = false;
044        node.typeNull_value = null;
045        node.in$Circle(false);
046        node.is$Final(false);
047        return node;
048      }
049    /**
050     * @apilevel internal
051     */
052      @SuppressWarnings({"unchecked", "cast"})
053    public ThrowStmt copy() {
054      
055      try {
056        ThrowStmt node = (ThrowStmt) clone();
057        node.parent = null;
058        if(children != null)
059          node.children = (ASTNode[]) children.clone();
060        
061        return node;
062      } catch (CloneNotSupportedException e) {
063        throw new Error("Error: clone not supported for " + getClass().getName());
064      }
065      
066    }/**
067     * Create a deep copy of the AST subtree at this node.
068     * The copy is dangling, i.e. has no parent.
069     * @return dangling copy of the subtree at this node
070     * @apilevel low-level
071     */
072      @SuppressWarnings({"unchecked", "cast"})
073    public ThrowStmt fullCopy() {
074      
075      ThrowStmt tree = (ThrowStmt) copy();
076      if (children != null) {
077        for (int i = 0; i < children.length; ++i) {
078          
079          ASTNode child = (ASTNode) children[i];
080          if(child != null) {
081            child = child.fullCopy();
082            tree.setChild(child, i);
083          }
084        }
085      }
086      return tree;
087      
088    }  /**
089       * @ast method 
090       * @aspect AnonymousClasses
091       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/AnonymousClasses.jrag:207
092       */
093      protected void collectExceptions(Collection c, ASTNode target) {
094        super.collectExceptions(c, target);
095        TypeDecl exceptionType = getExpr().type();
096        if(exceptionType == typeNull())
097          exceptionType = typeNullPointerException();
098        c.add(exceptionType);
099      }
100      /**
101       * @ast method 
102       * @aspect PrettyPrint
103       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:692
104       */
105      public void toString(StringBuffer s) {
106        s.append(indent());
107        s.append("throw ");
108        getExpr().toString(s);
109        s.append(";");
110      }
111      /**
112       * @ast method 
113       * @aspect TypeCheck
114       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:373
115       */
116      public void typeCheck() {
117        if(!getExpr().type().instanceOf(typeThrowable()))
118          error("*** The thrown expression must extend Throwable");
119      }
120      /**
121       * @ast method 
122       * @aspect CreateBCode
123       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1469
124       */
125      public void createBCode(CodeGeneration gen) {
126        super.createBCode(gen);
127        getExpr().createBCode(gen);
128        gen.emitThrow();
129      }
130      /**
131       * @ast method 
132       * 
133       */
134      public ThrowStmt() {
135        super();
136    
137    
138      }
139      /**
140       * Initializes the child array to the correct size.
141       * Initializes List and Opt nta children.
142       * @apilevel internal
143       * @ast method
144       * @ast method 
145       * 
146       */
147      public void init$Children() {
148        children = new ASTNode[1];
149      }
150      /**
151       * @ast method 
152       * 
153       */
154      public ThrowStmt(Expr p0) {
155        setChild(p0, 0);
156      }
157      /**
158       * @apilevel low-level
159       * @ast method 
160       * 
161       */
162      protected int numChildren() {
163        return 1;
164      }
165      /**
166       * @apilevel internal
167       * @ast method 
168       * 
169       */
170      public boolean mayHaveRewrite() {
171        return false;
172      }
173      /**
174       * Replaces the Expr child.
175       * @param node The new node to replace the Expr child.
176       * @apilevel high-level
177       * @ast method 
178       * 
179       */
180      public void setExpr(Expr node) {
181        setChild(node, 0);
182      }
183      /**
184       * Retrieves the Expr child.
185       * @return The current node used as the Expr child.
186       * @apilevel high-level
187       * @ast method 
188       * 
189       */
190      public Expr getExpr() {
191        return (Expr)getChild(0);
192      }
193      /**
194       * Retrieves the Expr child.
195       * <p><em>This method does not invoke AST transformations.</em></p>
196       * @return The current node used as the Expr child.
197       * @apilevel low-level
198       * @ast method 
199       * 
200       */
201      public Expr getExprNoTransform() {
202        return (Expr)getChildNoTransform(0);
203      }
204      /**
205       * @ast method 
206       * @aspect PreciseRethrow
207       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:163
208       */
209       
210       public void exceptionHandling() {
211               Collection<TypeDecl> exceptionTypes = getExpr().throwTypes();
212               for (TypeDecl exceptionType : exceptionTypes) {
213                       if (exceptionType == typeNull())
214                               exceptionType = typeNullPointerException();
215                       // 8.4.4
216                       if (!handlesException(exceptionType))
217                               error(""+this+" throws uncaught exception "+
218                                               exceptionType.fullName());
219               }
220       }
221      /**
222       * @ast method 
223       * @aspect PreciseRethrow
224       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:176
225       */
226       
227       protected boolean reachedException(TypeDecl catchType) {
228               Collection<TypeDecl> exceptionTypes = getExpr().throwTypes();
229               boolean reached = false;
230               for (TypeDecl exceptionType : exceptionTypes) {
231                       if(exceptionType == typeNull())
232                               exceptionType = typeNullPointerException();
233                       if(catchType.mayCatch(exceptionType)) {
234                               reached = true;
235                               break;
236                       }
237                       if (super.reachedException(catchType)) {
238                               reached = true;
239                               break;
240                       }
241               }
242               return reached;
243       }
244      protected java.util.Map isDAafter_Variable_values;
245      /**
246       * @attribute syn
247       * @aspect DA
248       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:650
249       */
250      @SuppressWarnings({"unchecked", "cast"})
251      public boolean isDAafter(Variable v) {
252        Object _parameters = v;
253        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
254        if(isDAafter_Variable_values.containsKey(_parameters)) {
255          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
256        }
257          ASTNode$State state = state();
258      int num = state.boundariesCrossed;
259      boolean isFinal = this.is$Final();
260        boolean isDAafter_Variable_value = isDAafter_compute(v);
261      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
262            return isDAafter_Variable_value;
263      }
264      /**
265       * @apilevel internal
266       */
267      private boolean isDAafter_compute(Variable v) {  return true;  }
268      protected java.util.Map isDUafter_Variable_values;
269      /**
270       * @attribute syn
271       * @aspect DU
272       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1173
273       */
274      @SuppressWarnings({"unchecked", "cast"})
275      public boolean isDUafter(Variable v) {
276        Object _parameters = v;
277        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
278        if(isDUafter_Variable_values.containsKey(_parameters)) {
279          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
280        }
281          ASTNode$State state = state();
282      int num = state.boundariesCrossed;
283      boolean isFinal = this.is$Final();
284        boolean isDUafter_Variable_value = isDUafter_compute(v);
285      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
286            return isDUafter_Variable_value;
287      }
288      /**
289       * @apilevel internal
290       */
291      private boolean isDUafter_compute(Variable v) {  return true;  }
292      /**
293       * @apilevel internal
294       */
295      protected boolean canCompleteNormally_computed = false;
296      /**
297       * @apilevel internal
298       */
299      protected boolean canCompleteNormally_value;
300      /**
301       * @attribute syn
302       * @aspect UnreachableStatements
303       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:108
304       */
305      @SuppressWarnings({"unchecked", "cast"})
306      public boolean canCompleteNormally() {
307        if(canCompleteNormally_computed) {
308          return canCompleteNormally_value;
309        }
310          ASTNode$State state = state();
311      int num = state.boundariesCrossed;
312      boolean isFinal = this.is$Final();
313        canCompleteNormally_value = canCompleteNormally_compute();
314      if(isFinal && num == state().boundariesCrossed){ canCompleteNormally_computed = true; }
315            return canCompleteNormally_value;
316      }
317      /**
318       * @apilevel internal
319       */
320      private boolean canCompleteNormally_compute() {  return false;  }
321      /**
322       * @attribute syn
323       * @aspect PreciseRethrow
324       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:55
325       */
326      public boolean modifiedInScope(Variable var) {
327        ASTNode$State state = state();
328        try {  return false;  }
329        finally {
330        }
331      }
332      /**
333       * @apilevel internal
334       */
335      protected boolean typeNullPointerException_computed = false;
336      /**
337       * @apilevel internal
338       */
339      protected TypeDecl typeNullPointerException_value;
340      /**
341       * @attribute inh
342       * @aspect ExceptionHandling
343       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ExceptionHandling.jrag:20
344       */
345      @SuppressWarnings({"unchecked", "cast"})
346      public TypeDecl typeNullPointerException() {
347        if(typeNullPointerException_computed) {
348          return typeNullPointerException_value;
349        }
350          ASTNode$State state = state();
351      int num = state.boundariesCrossed;
352      boolean isFinal = this.is$Final();
353        typeNullPointerException_value = getParent().Define_TypeDecl_typeNullPointerException(this, null);
354      if(isFinal && num == state().boundariesCrossed){ typeNullPointerException_computed = true; }
355            return typeNullPointerException_value;
356      }
357      protected java.util.Map handlesException_TypeDecl_values;
358      /**
359       * @attribute inh
360       * @aspect ExceptionHandling
361       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ExceptionHandling.jrag:45
362       */
363      @SuppressWarnings({"unchecked", "cast"})
364      public boolean handlesException(TypeDecl exceptionType) {
365        Object _parameters = exceptionType;
366        if(handlesException_TypeDecl_values == null) handlesException_TypeDecl_values = new java.util.HashMap(4);
367        if(handlesException_TypeDecl_values.containsKey(_parameters)) {
368          return ((Boolean)handlesException_TypeDecl_values.get(_parameters)).booleanValue();
369        }
370          ASTNode$State state = state();
371      int num = state.boundariesCrossed;
372      boolean isFinal = this.is$Final();
373        boolean handlesException_TypeDecl_value = getParent().Define_boolean_handlesException(this, null, exceptionType);
374      if(isFinal && num == state().boundariesCrossed){ handlesException_TypeDecl_values.put(_parameters, Boolean.valueOf(handlesException_TypeDecl_value)); }
375            return handlesException_TypeDecl_value;
376      }
377      /**
378       * @apilevel internal
379       */
380      protected boolean typeThrowable_computed = false;
381      /**
382       * @apilevel internal
383       */
384      protected TypeDecl typeThrowable_value;
385      /**
386       * @attribute inh
387       * @aspect SpecialClasses
388       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupType.jrag:67
389       */
390      @SuppressWarnings({"unchecked", "cast"})
391      public TypeDecl typeThrowable() {
392        if(typeThrowable_computed) {
393          return typeThrowable_value;
394        }
395          ASTNode$State state = state();
396      int num = state.boundariesCrossed;
397      boolean isFinal = this.is$Final();
398        typeThrowable_value = getParent().Define_TypeDecl_typeThrowable(this, null);
399      if(isFinal && num == state().boundariesCrossed){ typeThrowable_computed = true; }
400            return typeThrowable_value;
401      }
402      /**
403       * @apilevel internal
404       */
405      protected boolean typeNull_computed = false;
406      /**
407       * @apilevel internal
408       */
409      protected TypeDecl typeNull_value;
410      /**
411       * @attribute inh
412       * @aspect SpecialClasses
413       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupType.jrag:70
414       */
415      @SuppressWarnings({"unchecked", "cast"})
416      public TypeDecl typeNull() {
417        if(typeNull_computed) {
418          return typeNull_value;
419        }
420          ASTNode$State state = state();
421      int num = state.boundariesCrossed;
422      boolean isFinal = this.is$Final();
423        typeNull_value = getParent().Define_TypeDecl_typeNull(this, null);
424      if(isFinal && num == state().boundariesCrossed){ typeNull_computed = true; }
425            return typeNull_value;
426      }
427      /**
428       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:653
429       * @apilevel internal
430       */
431      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
432        if(caller == getExprNoTransform()) {
433          return isDAbefore(v);
434        }
435        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
436        }
437      }
438      /**
439       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1176
440       * @apilevel internal
441       */
442      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
443        if(caller == getExprNoTransform()) {
444          return isDUbefore(v);
445        }
446        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
447        }
448      }
449      /**
450       * @apilevel internal
451       */
452      public ASTNode rewriteTo() {
453        return super.rewriteTo();
454      }
455    }