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 LocalClassDeclStmt : {@link Stmt} ::= <span class="component">{@link ClassDecl}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:223
017     */
018    public class LocalClassDeclStmt 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 LocalClassDeclStmt clone() throws CloneNotSupportedException {
034        LocalClassDeclStmt node = (LocalClassDeclStmt)super.clone();
035        node.isDAafter_Variable_values = null;
036        node.isDUafter_Variable_values = null;
037        node.canCompleteNormally_computed = false;
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 LocalClassDeclStmt copy() {
047      
048      try {
049        LocalClassDeclStmt node = (LocalClassDeclStmt) 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 LocalClassDeclStmt fullCopy() {
067      
068      LocalClassDeclStmt tree = (LocalClassDeclStmt) 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 PrettyPrint
084       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:740
085       */
086      public void toString(StringBuffer s) {
087        getClassDecl().toString(s);
088      }
089      /**
090       * @ast method 
091       * @aspect CreateBCode
092       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1568
093       */
094      public void createBCode(CodeGeneration gen) {
095      }
096      /**
097       * @ast method 
098       * @aspect GenerateClassfile
099       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/GenerateClassfile.jrag:348
100       */
101      public boolean clear() {
102        for(int i = 0; i < getNumChild(); i++)
103          getChild(i).clear();
104        setParent(null);
105        flushCache();
106        return true;
107      }
108      /**
109       * @ast method 
110       * 
111       */
112      public LocalClassDeclStmt() {
113        super();
114    
115    
116      }
117      /**
118       * Initializes the child array to the correct size.
119       * Initializes List and Opt nta children.
120       * @apilevel internal
121       * @ast method
122       * @ast method 
123       * 
124       */
125      public void init$Children() {
126        children = new ASTNode[1];
127      }
128      /**
129       * @ast method 
130       * 
131       */
132      public LocalClassDeclStmt(ClassDecl p0) {
133        setChild(p0, 0);
134      }
135      /**
136       * @apilevel low-level
137       * @ast method 
138       * 
139       */
140      protected int numChildren() {
141        return 1;
142      }
143      /**
144       * @apilevel internal
145       * @ast method 
146       * 
147       */
148      public boolean mayHaveRewrite() {
149        return false;
150      }
151      /**
152       * Replaces the ClassDecl child.
153       * @param node The new node to replace the ClassDecl child.
154       * @apilevel high-level
155       * @ast method 
156       * 
157       */
158      public void setClassDecl(ClassDecl node) {
159        setChild(node, 0);
160      }
161      /**
162       * Retrieves the ClassDecl child.
163       * @return The current node used as the ClassDecl child.
164       * @apilevel high-level
165       * @ast method 
166       * 
167       */
168      public ClassDecl getClassDecl() {
169        return (ClassDecl)getChild(0);
170      }
171      /**
172       * Retrieves the ClassDecl child.
173       * <p><em>This method does not invoke AST transformations.</em></p>
174       * @return The current node used as the ClassDecl child.
175       * @apilevel low-level
176       * @ast method 
177       * 
178       */
179      public ClassDecl getClassDeclNoTransform() {
180        return (ClassDecl)getChildNoTransform(0);
181      }
182      protected java.util.Map isDAafter_Variable_values;
183      /**
184       * @attribute syn
185       * @aspect DA
186       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:490
187       */
188      @SuppressWarnings({"unchecked", "cast"})
189      public boolean isDAafter(Variable v) {
190        Object _parameters = v;
191        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
192        if(isDAafter_Variable_values.containsKey(_parameters)) {
193          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
194        }
195          ASTNode$State state = state();
196      int num = state.boundariesCrossed;
197      boolean isFinal = this.is$Final();
198        boolean isDAafter_Variable_value = isDAafter_compute(v);
199      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
200            return isDAafter_Variable_value;
201      }
202      /**
203       * @apilevel internal
204       */
205      private boolean isDAafter_compute(Variable v) {  return isDAbefore(v);  }
206      protected java.util.Map isDUafter_Variable_values;
207      /**
208       * @attribute syn
209       * @aspect DU
210       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:873
211       */
212      @SuppressWarnings({"unchecked", "cast"})
213      public boolean isDUafter(Variable v) {
214        Object _parameters = v;
215        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
216        if(isDUafter_Variable_values.containsKey(_parameters)) {
217          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
218        }
219          ASTNode$State state = state();
220      int num = state.boundariesCrossed;
221      boolean isFinal = this.is$Final();
222        boolean isDUafter_Variable_value = isDUafter_compute(v);
223      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
224            return isDUafter_Variable_value;
225      }
226      /**
227       * @apilevel internal
228       */
229      private boolean isDUafter_compute(Variable v) {  return isDUbefore(v);  }
230      /**
231       * @apilevel internal
232       */
233      protected boolean canCompleteNormally_computed = false;
234      /**
235       * @apilevel internal
236       */
237      protected boolean canCompleteNormally_value;
238      /**
239       * @attribute syn
240       * @aspect UnreachableStatements
241       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:40
242       */
243      @SuppressWarnings({"unchecked", "cast"})
244      public boolean canCompleteNormally() {
245        if(canCompleteNormally_computed) {
246          return canCompleteNormally_value;
247        }
248          ASTNode$State state = state();
249      int num = state.boundariesCrossed;
250      boolean isFinal = this.is$Final();
251        canCompleteNormally_value = canCompleteNormally_compute();
252      if(isFinal && num == state().boundariesCrossed){ canCompleteNormally_computed = true; }
253            return canCompleteNormally_value;
254      }
255      /**
256       * @apilevel internal
257       */
258      private boolean canCompleteNormally_compute() {  return reachable();  }
259      /**
260       * @attribute syn
261       * @aspect GenerateClassfile
262       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/GenerateClassfile.jrag:325
263       */
264      public boolean flush() {
265        ASTNode$State state = state();
266        try {  return true;  }
267        finally {
268        }
269      }
270      /**
271       * @attribute syn
272       * @aspect PreciseRethrow
273       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:55
274       */
275      public boolean modifiedInScope(Variable var) {
276        ASTNode$State state = state();
277        try {  return false;  }
278        finally {
279        }
280      }
281      /**
282       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:543
283       * @apilevel internal
284       */
285      public boolean Define_boolean_isLocalClass(ASTNode caller, ASTNode child) {
286        if(caller == getClassDeclNoTransform()) {
287          return true;
288        }
289        else {      return getParent().Define_boolean_isLocalClass(this, caller);
290        }
291      }
292      /**
293       * @apilevel internal
294       */
295      public ASTNode rewriteTo() {
296        return super.rewriteTo();
297      }
298    }