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 InstanceInitializer : {@link BodyDecl} ::= <span class="component">{@link Block}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:73
017     */
018    public class InstanceInitializer extends BodyDecl 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 InstanceInitializer clone() throws CloneNotSupportedException {
034        InstanceInitializer node = (InstanceInitializer)super.clone();
035        node.exceptions_computed = false;
036        node.exceptions_value = null;
037        node.isDAafter_Variable_values = null;
038        node.isDUafter_Variable_values = null;
039        node.handlesException_TypeDecl_values = null;
040        node.in$Circle(false);
041        node.is$Final(false);
042        return node;
043      }
044    /**
045     * @apilevel internal
046     */
047      @SuppressWarnings({"unchecked", "cast"})
048    public InstanceInitializer copy() {
049      
050      try {
051        InstanceInitializer node = (InstanceInitializer) clone();
052        node.parent = null;
053        if(children != null)
054          node.children = (ASTNode[]) children.clone();
055        
056        return node;
057      } catch (CloneNotSupportedException e) {
058        throw new Error("Error: clone not supported for " + getClass().getName());
059      }
060      
061    }/**
062     * Create a deep copy of the AST subtree at this node.
063     * The copy is dangling, i.e. has no parent.
064     * @return dangling copy of the subtree at this node
065     * @apilevel low-level
066     */
067      @SuppressWarnings({"unchecked", "cast"})
068    public InstanceInitializer fullCopy() {
069      
070      InstanceInitializer tree = (InstanceInitializer) copy();
071      if (children != null) {
072        for (int i = 0; i < children.length; ++i) {
073          
074          ASTNode child = (ASTNode) children[i];
075          if(child != null) {
076            child = child.fullCopy();
077            tree.setChild(child, i);
078          }
079        }
080      }
081      return tree;
082      
083    }  /**
084       * @ast method 
085       * @aspect PrettyPrint
086       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:106
087       */
088      public void toString(StringBuffer s) {
089        if(getBlock().getNumStmt() == 0) return;
090        s.append(indent());
091        getBlock().toString(s);
092      }
093      /**
094       * @ast method 
095       * @aspect UnreachableStatements
096       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:22
097       */
098      void checkUnreachableStmt() {
099        if(!getBlock().canCompleteNormally())
100          error("instance initializer in " + hostType().fullName() + " can not complete normally");
101      }
102      /**
103       * @ast method 
104       * 
105       */
106      public InstanceInitializer() {
107        super();
108    
109    
110      }
111      /**
112       * Initializes the child array to the correct size.
113       * Initializes List and Opt nta children.
114       * @apilevel internal
115       * @ast method
116       * @ast method 
117       * 
118       */
119      public void init$Children() {
120        children = new ASTNode[1];
121      }
122      /**
123       * @ast method 
124       * 
125       */
126      public InstanceInitializer(Block p0) {
127        setChild(p0, 0);
128      }
129      /**
130       * @apilevel low-level
131       * @ast method 
132       * 
133       */
134      protected int numChildren() {
135        return 1;
136      }
137      /**
138       * @apilevel internal
139       * @ast method 
140       * 
141       */
142      public boolean mayHaveRewrite() {
143        return false;
144      }
145      /**
146       * Replaces the Block child.
147       * @param node The new node to replace the Block child.
148       * @apilevel high-level
149       * @ast method 
150       * 
151       */
152      public void setBlock(Block node) {
153        setChild(node, 0);
154      }
155      /**
156       * Retrieves the Block child.
157       * @return The current node used as the Block child.
158       * @apilevel high-level
159       * @ast method 
160       * 
161       */
162      public Block getBlock() {
163        return (Block)getChild(0);
164      }
165      /**
166       * Retrieves the Block child.
167       * <p><em>This method does not invoke AST transformations.</em></p>
168       * @return The current node used as the Block child.
169       * @apilevel low-level
170       * @ast method 
171       * 
172       */
173      public Block getBlockNoTransform() {
174        return (Block)getChildNoTransform(0);
175      }
176      /**
177       * @apilevel internal
178       */
179      protected boolean exceptions_computed = false;
180      /**
181       * @apilevel internal
182       */
183      protected Collection exceptions_value;
184      /**
185       * @attribute syn
186       * @aspect AnonymousClasses
187       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/AnonymousClasses.jrag:191
188       */
189      @SuppressWarnings({"unchecked", "cast"})
190      public Collection exceptions() {
191        if(exceptions_computed) {
192          return exceptions_value;
193        }
194          ASTNode$State state = state();
195      int num = state.boundariesCrossed;
196      boolean isFinal = this.is$Final();
197        exceptions_value = exceptions_compute();
198      if(isFinal && num == state().boundariesCrossed){ exceptions_computed = true; }
199            return exceptions_value;
200      }
201      /**
202       * @apilevel internal
203       */
204      private Collection exceptions_compute() {
205        HashSet set = new HashSet();
206        collectExceptions(set, this);
207        for(Iterator iter = set.iterator(); iter.hasNext(); ) {
208          TypeDecl typeDecl = (TypeDecl)iter.next();
209          if(!getBlock().reachedException(typeDecl))
210            iter.remove();
211        }
212        return set;
213      }
214      protected java.util.Map isDAafter_Variable_values;
215      /**
216       * @attribute syn
217       * @aspect DA
218       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:292
219       */
220      @SuppressWarnings({"unchecked", "cast"})
221      public boolean isDAafter(Variable v) {
222        Object _parameters = v;
223        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
224        if(isDAafter_Variable_values.containsKey(_parameters)) {
225          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
226        }
227          ASTNode$State state = state();
228      int num = state.boundariesCrossed;
229      boolean isFinal = this.is$Final();
230        boolean isDAafter_Variable_value = isDAafter_compute(v);
231      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
232            return isDAafter_Variable_value;
233      }
234      /**
235       * @apilevel internal
236       */
237      private boolean isDAafter_compute(Variable v) {  return getBlock().isDAafter(v);  }
238      protected java.util.Map isDUafter_Variable_values;
239      /**
240       * @attribute syn
241       * @aspect DU
242       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:749
243       */
244      @SuppressWarnings({"unchecked", "cast"})
245      public boolean isDUafter(Variable v) {
246        Object _parameters = v;
247        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
248        if(isDUafter_Variable_values.containsKey(_parameters)) {
249          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
250        }
251          ASTNode$State state = state();
252      int num = state.boundariesCrossed;
253      boolean isFinal = this.is$Final();
254        boolean isDUafter_Variable_value = isDUafter_compute(v);
255      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
256            return isDUafter_Variable_value;
257      }
258      /**
259       * @apilevel internal
260       */
261      private boolean isDUafter_compute(Variable v) {  return getBlock().isDUafter(v);  }
262      protected java.util.Map handlesException_TypeDecl_values;
263      /**
264       * @attribute inh
265       * @aspect ExceptionHandling
266       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ExceptionHandling.jrag:46
267       */
268      @SuppressWarnings({"unchecked", "cast"})
269      public boolean handlesException(TypeDecl exceptionType) {
270        Object _parameters = exceptionType;
271        if(handlesException_TypeDecl_values == null) handlesException_TypeDecl_values = new java.util.HashMap(4);
272        if(handlesException_TypeDecl_values.containsKey(_parameters)) {
273          return ((Boolean)handlesException_TypeDecl_values.get(_parameters)).booleanValue();
274        }
275          ASTNode$State state = state();
276      int num = state.boundariesCrossed;
277      boolean isFinal = this.is$Final();
278        boolean handlesException_TypeDecl_value = getParent().Define_boolean_handlesException(this, null, exceptionType);
279      if(isFinal && num == state().boundariesCrossed){ handlesException_TypeDecl_values.put(_parameters, Boolean.valueOf(handlesException_TypeDecl_value)); }
280            return handlesException_TypeDecl_value;
281      }
282      /**
283       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:438
284       * @apilevel internal
285       */
286      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
287        if(caller == getBlockNoTransform()) {
288          return isDAbefore(v);
289        }
290        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
291        }
292      }
293      /**
294       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ExceptionHandling.jrag:180
295       * @apilevel internal
296       */
297      public boolean Define_boolean_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
298        if(caller == getBlockNoTransform()){
299        if(hostType().isAnonymous())
300          return true;
301        if(!exceptionType.isUncheckedException())
302          return true;
303        for(Iterator iter = hostType().constructors().iterator(); iter.hasNext(); ) {
304          ConstructorDecl decl = (ConstructorDecl)iter.next();
305          if(!decl.throwsException(exceptionType))
306            return false;
307        }
308        return true;
309      }
310        else {      return getParent().Define_boolean_handlesException(this, caller, exceptionType);
311        }
312      }
313      /**
314       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:248
315       * @apilevel internal
316       */
317      public ASTNode Define_ASTNode_enclosingBlock(ASTNode caller, ASTNode child) {
318        if(caller == getBlockNoTransform()) {
319          return this;
320        }
321        else {      return getParent().Define_ASTNode_enclosingBlock(this, caller);
322        }
323      }
324      /**
325       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeHierarchyCheck.jrag:140
326       * @apilevel internal
327       */
328      public boolean Define_boolean_inStaticContext(ASTNode caller, ASTNode child) {
329        if(caller == getBlockNoTransform()) {
330          return false;
331        }
332        else {      return getParent().Define_boolean_inStaticContext(this, caller);
333        }
334      }
335      /**
336       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:35
337       * @apilevel internal
338       */
339      public boolean Define_boolean_reachable(ASTNode caller, ASTNode child) {
340        if(caller == getBlockNoTransform()) {
341          return true;
342        }
343        else {      return getParent().Define_boolean_reachable(this, caller);
344        }
345      }
346      /**
347       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/LocalNum.jrag:32
348       * @apilevel internal
349       */
350      public int Define_int_localNum(ASTNode caller, ASTNode child) {
351        if(caller == getBlockNoTransform()){
352        int localNum = 1;
353        for(Iterator iter = hostType().constructors().iterator(); iter.hasNext(); ) {
354          ConstructorDecl c = (ConstructorDecl)iter.next();
355          int num = c.getNumParameter() == 0 ? c.localNumOfFirstParameter() : 
356                    c.getParameter(c.getNumParameter()-1).localNum() + c.getParameter(c.getNumParameter()-1).type().variableSize();
357          if(num > localNum)
358            localNum = num;
359        }
360        return localNum;
361      }
362        else {      return getParent().Define_int_localNum(this, caller);
363        }
364      }
365      /**
366       * @apilevel internal
367       */
368      public ASTNode rewriteTo() {
369        return super.rewriteTo();
370      }
371    }