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