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    /**
015     * @production Block : {@link Stmt} ::= <span class="component">{@link Stmt}*</span>;
016     * @ast node
017     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:197
018     */
019    public class Block extends Stmt implements Cloneable, VariableScope {
020      /**
021       * @apilevel low-level
022       */
023      public void flushCache() {
024      }
025      /**
026       * @apilevel internal
027       */
028      public void flushCollectionCache() {
029      }
030      /**
031       * @apilevel internal
032       */
033      @SuppressWarnings({"unchecked", "cast"})
034      public Block clone() throws CloneNotSupportedException {
035        Block node = (Block)super.clone();
036        node.checkReturnDA_Variable_values = null;
037        node.isDAafter_Variable_values = null;
038        node.checkReturnDU_Variable_values = null;
039        node.isDUafter_Variable_values = null;
040        node.localVariableDeclaration_String_values = null;
041        node.canCompleteNormally_computed = false;
042        node.variableScopeEndLabel_CodeGeneration_values = null;
043        node.lookupType_String_values = null;
044        node.lookupVariable_String_values = 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 Block copy() {
054      
055      try {
056        Block node = (Block) 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 Block fullCopy() {
074      
075      Block tree = (Block) 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 DeclareBeforeUse
091       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DeclareBeforeUse.jrag:21
092       */
093      public boolean declaredBeforeUse(Variable decl, ASTNode use) {
094        int indexDecl = ((ASTNode)decl).varChildIndex(this);
095        int indexUse = use.varChildIndex(this);
096        return indexDecl <= indexUse;
097      }
098      /**
099       * @ast method 
100       * @aspect DeclareBeforeUse
101       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DeclareBeforeUse.jrag:26
102       */
103      public boolean declaredBeforeUse(Variable decl, int indexUse) {
104        int indexDecl = ((ASTNode)decl).varChildIndex(this);
105        return indexDecl <= indexUse;
106      }
107      /**
108       * @ast method 
109       * @aspect PrettyPrint
110       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:526
111       */
112      public void toString(StringBuffer s) {
113        String indent = indent();
114        s.append(shouldHaveIndent() ? indent : "");
115        s.append("{");
116        for(int i = 0; i < getNumStmt(); i++) {
117          getStmt(i).toString(s);
118        }
119        s.append(shouldHaveIndent() ? indent : indent.substring(0, indent.length()-2));
120        s.append("}");
121      }
122      /**
123       * @ast method 
124       * @aspect CreateBCode
125       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1178
126       */
127      public void createBCode(CodeGeneration gen) {
128        //super.createBCode(gen);
129        for(int i = 0; i < getNumStmt(); i++) {
130          try {
131            getStmt(i).createBCode(gen);
132          } catch (Exception e) {
133            e.printStackTrace();
134            throw new Error("Error generating code for " + errorPrefix() + " " + getStmt(i));
135          }
136        }
137        gen.addVariableScopeLabel(variableScopeEndLabel(gen));
138      }
139      /**
140       * @ast method 
141       * 
142       */
143      public Block() {
144        super();
145    
146    
147      }
148      /**
149       * Initializes the child array to the correct size.
150       * Initializes List and Opt nta children.
151       * @apilevel internal
152       * @ast method
153       * @ast method 
154       * 
155       */
156      public void init$Children() {
157        children = new ASTNode[1];
158        setChild(new List(), 0);
159      }
160      /**
161       * @ast method 
162       * 
163       */
164      public Block(List<Stmt> p0) {
165        setChild(p0, 0);
166      }
167      /**
168       * @apilevel low-level
169       * @ast method 
170       * 
171       */
172      protected int numChildren() {
173        return 1;
174      }
175      /**
176       * @apilevel internal
177       * @ast method 
178       * 
179       */
180      public boolean mayHaveRewrite() {
181        return false;
182      }
183      /**
184       * Replaces the Stmt list.
185       * @param list The new list node to be used as the Stmt list.
186       * @apilevel high-level
187       * @ast method 
188       * 
189       */
190      public void setStmtList(List<Stmt> list) {
191        setChild(list, 0);
192      }
193      /**
194       * Retrieves the number of children in the Stmt list.
195       * @return Number of children in the Stmt list.
196       * @apilevel high-level
197       * @ast method 
198       * 
199       */
200      public int getNumStmt() {
201        return getStmtList().getNumChild();
202      }
203      /**
204       * Retrieves the number of children in the Stmt list.
205       * Calling this method will not trigger rewrites..
206       * @return Number of children in the Stmt list.
207       * @apilevel low-level
208       * @ast method 
209       * 
210       */
211      public int getNumStmtNoTransform() {
212        return getStmtListNoTransform().getNumChildNoTransform();
213      }
214      /**
215       * Retrieves the element at index {@code i} in the Stmt list..
216       * @param i Index of the element to return.
217       * @return The element at position {@code i} in the Stmt list.
218       * @apilevel high-level
219       * @ast method 
220       * 
221       */
222      @SuppressWarnings({"unchecked", "cast"})
223      public Stmt getStmt(int i) {
224        return (Stmt)getStmtList().getChild(i);
225      }
226      /**
227       * Append an element to the Stmt list.
228       * @param node The element to append to the Stmt list.
229       * @apilevel high-level
230       * @ast method 
231       * 
232       */
233      public void addStmt(Stmt node) {
234        List<Stmt> list = (parent == null || state == null) ? getStmtListNoTransform() : getStmtList();
235        list.addChild(node);
236      }
237      /**
238       * @apilevel low-level
239       * @ast method 
240       * 
241       */
242      public void addStmtNoTransform(Stmt node) {
243        List<Stmt> list = getStmtListNoTransform();
244        list.addChild(node);
245      }
246      /**
247       * Replaces the Stmt list element at index {@code i} with the new node {@code node}.
248       * @param node The new node to replace the old list element.
249       * @param i The list index of the node to be replaced.
250       * @apilevel high-level
251       * @ast method 
252       * 
253       */
254      public void setStmt(Stmt node, int i) {
255        List<Stmt> list = getStmtList();
256        list.setChild(node, i);
257      }
258      /**
259       * Retrieves the Stmt list.
260       * @return The node representing the Stmt list.
261       * @apilevel high-level
262       * @ast method 
263       * 
264       */
265      public List<Stmt> getStmts() {
266        return getStmtList();
267      }
268      /**
269       * Retrieves the Stmt list.
270       * <p><em>This method does not invoke AST transformations.</em></p>
271       * @return The node representing the Stmt list.
272       * @apilevel low-level
273       * @ast method 
274       * 
275       */
276      public List<Stmt> getStmtsNoTransform() {
277        return getStmtListNoTransform();
278      }
279      /**
280       * Retrieves the Stmt list.
281       * @return The node representing the Stmt list.
282       * @apilevel high-level
283       * @ast method 
284       * 
285       */
286      @SuppressWarnings({"unchecked", "cast"})
287      public List<Stmt> getStmtList() {
288        List<Stmt> list = (List<Stmt>)getChild(0);
289        list.getNumChild();
290        return list;
291      }
292      /**
293       * Retrieves the Stmt list.
294       * <p><em>This method does not invoke AST transformations.</em></p>
295       * @return The node representing the Stmt list.
296       * @apilevel low-level
297       * @ast method 
298       * 
299       */
300      @SuppressWarnings({"unchecked", "cast"})
301      public List<Stmt> getStmtListNoTransform() {
302        return (List<Stmt>)getChildNoTransform(0);
303      }
304      protected java.util.Map checkReturnDA_Variable_values;
305      /**
306       * @attribute syn
307       * @aspect DA
308       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:300
309       */
310      @SuppressWarnings({"unchecked", "cast"})
311      public boolean checkReturnDA(Variable v) {
312        Object _parameters = v;
313        if(checkReturnDA_Variable_values == null) checkReturnDA_Variable_values = new java.util.HashMap(4);
314        if(checkReturnDA_Variable_values.containsKey(_parameters)) {
315          return ((Boolean)checkReturnDA_Variable_values.get(_parameters)).booleanValue();
316        }
317          ASTNode$State state = state();
318      int num = state.boundariesCrossed;
319      boolean isFinal = this.is$Final();
320        boolean checkReturnDA_Variable_value = checkReturnDA_compute(v);
321      if(isFinal && num == state().boundariesCrossed){ checkReturnDA_Variable_values.put(_parameters, Boolean.valueOf(checkReturnDA_Variable_value)); }
322            return checkReturnDA_Variable_value;
323      }
324      /**
325       * @apilevel internal
326       */
327      private boolean checkReturnDA_compute(Variable v) {
328        HashSet set = new HashSet();
329        collectBranches(set);
330        for(Iterator iter = set.iterator(); iter.hasNext(); ) {
331          Object o = iter.next();
332          if(o instanceof ReturnStmt) {
333            ReturnStmt stmt = (ReturnStmt)o;
334            if(!stmt.isDAafterReachedFinallyBlocks(v))
335              return false;
336          }
337        }
338        return true;
339      }
340      protected java.util.Map isDAafter_Variable_values;
341      /**
342       * @attribute syn
343       * @aspect DA
344       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:441
345       */
346      @SuppressWarnings({"unchecked", "cast"})
347      public boolean isDAafter(Variable v) {
348        Object _parameters = v;
349        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
350        if(isDAafter_Variable_values.containsKey(_parameters)) {
351          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
352        }
353          ASTNode$State state = state();
354      int num = state.boundariesCrossed;
355      boolean isFinal = this.is$Final();
356        boolean isDAafter_Variable_value = isDAafter_compute(v);
357      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
358            return isDAafter_Variable_value;
359      }
360      /**
361       * @apilevel internal
362       */
363      private boolean isDAafter_compute(Variable v) {  return getNumStmt() == 0 ? isDAbefore(v) : getStmt(getNumStmt()-1).isDAafter(v);  }
364      /**
365       * @attribute syn
366       * @aspect DA
367       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:447
368       */
369      public boolean isDUeverywhere(Variable v) {
370        ASTNode$State state = state();
371        try {  return isDUbefore(v) && checkDUeverywhere(v);  }
372        finally {
373        }
374      }
375      protected java.util.Map checkReturnDU_Variable_values;
376      /**
377       * @attribute syn
378       * @aspect DU
379       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:757
380       */
381      @SuppressWarnings({"unchecked", "cast"})
382      public boolean checkReturnDU(Variable v) {
383        Object _parameters = v;
384        if(checkReturnDU_Variable_values == null) checkReturnDU_Variable_values = new java.util.HashMap(4);
385        if(checkReturnDU_Variable_values.containsKey(_parameters)) {
386          return ((Boolean)checkReturnDU_Variable_values.get(_parameters)).booleanValue();
387        }
388          ASTNode$State state = state();
389      int num = state.boundariesCrossed;
390      boolean isFinal = this.is$Final();
391        boolean checkReturnDU_Variable_value = checkReturnDU_compute(v);
392      if(isFinal && num == state().boundariesCrossed){ checkReturnDU_Variable_values.put(_parameters, Boolean.valueOf(checkReturnDU_Variable_value)); }
393            return checkReturnDU_Variable_value;
394      }
395      /**
396       * @apilevel internal
397       */
398      private boolean checkReturnDU_compute(Variable v) {
399        HashSet set = new HashSet();
400        collectBranches(set);
401        for(Iterator iter = set.iterator(); iter.hasNext(); ) {
402          Object o = iter.next();
403          if(o instanceof ReturnStmt) {
404            ReturnStmt stmt = (ReturnStmt)o;
405            if(!stmt.isDUafterReachedFinallyBlocks(v))
406              return false;
407          }
408        }
409        return true;
410      }
411      protected java.util.Map isDUafter_Variable_values;
412      /**
413       * @attribute syn
414       * @aspect DU
415       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:870
416       */
417      @SuppressWarnings({"unchecked", "cast"})
418      public boolean isDUafter(Variable v) {
419        Object _parameters = v;
420        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
421        if(isDUafter_Variable_values.containsKey(_parameters)) {
422          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
423        }
424          ASTNode$State state = state();
425      int num = state.boundariesCrossed;
426      boolean isFinal = this.is$Final();
427        boolean isDUafter_Variable_value = isDUafter_compute(v);
428      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
429            return isDUafter_Variable_value;
430      }
431      /**
432       * @apilevel internal
433       */
434      private boolean isDUafter_compute(Variable v) {  return getNumStmt() == 0 ? isDUbefore(v) : getStmt(getNumStmt()-1).isDUafter(v);  }
435      protected java.util.Map localVariableDeclaration_String_values;
436      /**
437       * @attribute syn
438       * @aspect VariableScope
439       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupVariable.jrag:116
440       */
441      @SuppressWarnings({"unchecked", "cast"})
442      public VariableDeclaration localVariableDeclaration(String name) {
443        Object _parameters = name;
444        if(localVariableDeclaration_String_values == null) localVariableDeclaration_String_values = new java.util.HashMap(4);
445        if(localVariableDeclaration_String_values.containsKey(_parameters)) {
446          return (VariableDeclaration)localVariableDeclaration_String_values.get(_parameters);
447        }
448          ASTNode$State state = state();
449      int num = state.boundariesCrossed;
450      boolean isFinal = this.is$Final();
451        VariableDeclaration localVariableDeclaration_String_value = localVariableDeclaration_compute(name);
452      if(isFinal && num == state().boundariesCrossed){ localVariableDeclaration_String_values.put(_parameters, localVariableDeclaration_String_value); }
453            return localVariableDeclaration_String_value;
454      }
455      /**
456       * @apilevel internal
457       */
458      private VariableDeclaration localVariableDeclaration_compute(String name) {
459        for(int i = 0; i < getNumStmt(); i++)
460          if(getStmt(i).declaresVariable(name))
461            return (VariableDeclaration)getStmt(i);
462        return null;
463      }
464      /**
465       * @attribute syn
466       * @aspect PrettyPrint
467       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:758
468       */
469      public boolean addsIndentationLevel() {
470        ASTNode$State state = state();
471        try {  return shouldHaveIndent();  }
472        finally {
473        }
474      }
475      /**
476       * @attribute syn
477       * @aspect PrettyPrint
478       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:765
479       */
480      public boolean shouldHaveIndent() {
481        ASTNode$State state = state();
482        try {  return getParent() instanceof List && getParent().getParent() instanceof Block;  }
483        finally {
484        }
485      }
486      /**
487       * @apilevel internal
488       */
489      protected boolean canCompleteNormally_computed = false;
490      /**
491       * @apilevel internal
492       */
493      protected boolean canCompleteNormally_value;
494      /**
495       * @attribute syn
496       * @aspect UnreachableStatements
497       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:37
498       */
499      @SuppressWarnings({"unchecked", "cast"})
500      public boolean canCompleteNormally() {
501        if(canCompleteNormally_computed) {
502          return canCompleteNormally_value;
503        }
504          ASTNode$State state = state();
505      int num = state.boundariesCrossed;
506      boolean isFinal = this.is$Final();
507        canCompleteNormally_value = canCompleteNormally_compute();
508      if(isFinal && num == state().boundariesCrossed){ canCompleteNormally_computed = true; }
509            return canCompleteNormally_value;
510      }
511      /**
512       * @apilevel internal
513       */
514      private boolean canCompleteNormally_compute() {  return getNumStmt() == 0 ? reachable() : getStmt(getNumStmt() - 1).canCompleteNormally();  }
515      protected java.util.Map variableScopeEndLabel_CodeGeneration_values;
516      /**
517       * @attribute syn
518       * @aspect CodeGeneration
519       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:43
520       */
521      @SuppressWarnings({"unchecked", "cast"})
522      public int variableScopeEndLabel(CodeGeneration gen) {
523        Object _parameters = gen;
524        if(variableScopeEndLabel_CodeGeneration_values == null) variableScopeEndLabel_CodeGeneration_values = new java.util.HashMap(4);
525        if(variableScopeEndLabel_CodeGeneration_values.containsKey(_parameters)) {
526          return ((Integer)variableScopeEndLabel_CodeGeneration_values.get(_parameters)).intValue();
527        }
528          ASTNode$State state = state();
529      int num = state.boundariesCrossed;
530      boolean isFinal = this.is$Final();
531        int variableScopeEndLabel_CodeGeneration_value = variableScopeEndLabel_compute(gen);
532      if(isFinal && num == state().boundariesCrossed){ variableScopeEndLabel_CodeGeneration_values.put(_parameters, Integer.valueOf(variableScopeEndLabel_CodeGeneration_value)); }
533            return variableScopeEndLabel_CodeGeneration_value;
534      }
535      /**
536       * @apilevel internal
537       */
538      private int variableScopeEndLabel_compute(CodeGeneration gen) {  return gen.variableScopeLabel();  }
539      /**
540       * @attribute syn
541       * @aspect PreciseRethrow
542       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:55
543       */
544      public boolean modifiedInScope(Variable var) {
545        ASTNode$State state = state();
546        try {
547               for (Stmt stmt : getStmtList())
548                       if (stmt.modifiedInScope(var))
549                               return true;
550               return false;
551       }
552        finally {
553        }
554      }
555      protected java.util.Map lookupType_String_values;
556      /**
557       * @attribute inh
558       * @aspect TypeScopePropagation
559       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupType.jrag:263
560       */
561      @SuppressWarnings({"unchecked", "cast"})
562      public SimpleSet lookupType(String name) {
563        Object _parameters = name;
564        if(lookupType_String_values == null) lookupType_String_values = new java.util.HashMap(4);
565        if(lookupType_String_values.containsKey(_parameters)) {
566          return (SimpleSet)lookupType_String_values.get(_parameters);
567        }
568          ASTNode$State state = state();
569      int num = state.boundariesCrossed;
570      boolean isFinal = this.is$Final();
571        SimpleSet lookupType_String_value = getParent().Define_SimpleSet_lookupType(this, null, name);
572      if(isFinal && num == state().boundariesCrossed){ lookupType_String_values.put(_parameters, lookupType_String_value); }
573            return lookupType_String_value;
574      }
575      protected java.util.Map lookupVariable_String_values;
576      /**
577       * @attribute inh
578       * @aspect VariableScope
579       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupVariable.jrag:17
580       */
581      @SuppressWarnings({"unchecked", "cast"})
582      public SimpleSet lookupVariable(String name) {
583        Object _parameters = name;
584        if(lookupVariable_String_values == null) lookupVariable_String_values = new java.util.HashMap(4);
585        if(lookupVariable_String_values.containsKey(_parameters)) {
586          return (SimpleSet)lookupVariable_String_values.get(_parameters);
587        }
588          ASTNode$State state = state();
589      int num = state.boundariesCrossed;
590      boolean isFinal = this.is$Final();
591        SimpleSet lookupVariable_String_value = getParent().Define_SimpleSet_lookupVariable(this, null, name);
592      if(isFinal && num == state().boundariesCrossed){ lookupVariable_String_values.put(_parameters, lookupVariable_String_value); }
593            return lookupVariable_String_value;
594      }
595      /**
596       * @attribute inh
597       * @aspect UnreachableStatements
598       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:28
599       */
600      @SuppressWarnings({"unchecked", "cast"})
601      public boolean reachable() {
602          ASTNode$State state = state();
603        boolean reachable_value = getParent().Define_boolean_reachable(this, null);
604            return reachable_value;
605      }
606      /**
607       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:52
608       * @apilevel internal
609       */
610      public boolean Define_boolean_isIncOrDec(ASTNode caller, ASTNode child) {
611        if(caller == getStmtListNoTransform())  {
612        int childIndex = caller.getIndexOfChild(child);
613        return false;
614      }
615        else {      return getParent().Define_boolean_isIncOrDec(this, caller);
616        }
617      }
618      /**
619       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:444
620       * @apilevel internal
621       */
622      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
623        if(caller == getStmtListNoTransform())  {
624        int index = caller.getIndexOfChild(child);
625        return index == 0 ? isDAbefore(v) : getStmt(index - 1).isDAafter(v);
626      }
627        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
628        }
629      }
630      /**
631       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:871
632       * @apilevel internal
633       */
634      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
635        if(caller == getStmtListNoTransform())  {
636        int index = caller.getIndexOfChild(child);
637        return index == 0 ? isDUbefore(v) : getStmt(index - 1).isDUafter(v);
638      }
639        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
640        }
641      }
642      /**
643       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupType.jrag:380
644       * @apilevel internal
645       */
646      public SimpleSet Define_SimpleSet_lookupType(ASTNode caller, ASTNode child, String name) {
647        if(caller == getStmtListNoTransform())  { 
648        int index = caller.getIndexOfChild(child);
649        {
650        SimpleSet c = SimpleSet.emptySet;
651        for(int i = index; i >= 0 && !(getStmt(i) instanceof Case); i--) {
652          if(getStmt(i) instanceof LocalClassDeclStmt) {
653            TypeDecl t = ((LocalClassDeclStmt)getStmt(i)).getClassDecl();
654            if(t.name().equals(name)) {
655              c = c.add(t);
656            }
657          }
658        }
659        if(!c.isEmpty())
660          return c;
661        return lookupType(name);
662      }
663      }
664        else {      return getParent().Define_SimpleSet_lookupType(this, caller, name);
665        }
666      }
667      /**
668       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupVariable.jrag:68
669       * @apilevel internal
670       */
671      public SimpleSet Define_SimpleSet_lookupVariable(ASTNode caller, ASTNode child, String name) {
672        if(caller == getStmtListNoTransform())  { 
673        int index = caller.getIndexOfChild(child);
674        {
675        VariableDeclaration v = localVariableDeclaration(name);
676        // declare before use and shadowing
677        if(v != null && declaredBeforeUse(v, index))
678          return v;
679        return lookupVariable(name);
680      }
681      }
682        else {      return getParent().Define_SimpleSet_lookupVariable(this, caller, name);
683        }
684      }
685      /**
686       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:296
687       * @apilevel internal
688       */
689      public VariableScope Define_VariableScope_outerScope(ASTNode caller, ASTNode child) {
690        if(caller == getStmtListNoTransform())  {
691        int childIndex = caller.getIndexOfChild(child);
692        return this;
693      }
694        else {      return getParent().Define_VariableScope_outerScope(this, caller);
695        }
696      }
697      /**
698       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/SyntacticClassification.jrag:116
699       * @apilevel internal
700       */
701      public NameType Define_NameType_nameType(ASTNode caller, ASTNode child) {
702        if(caller == getStmtListNoTransform())  {
703        int childIndex = caller.getIndexOfChild(child);
704        return NameType.EXPRESSION_NAME;
705      }
706        else {      return getParent().Define_NameType_nameType(this, caller);
707        }
708      }
709      /**
710       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:38
711       * @apilevel internal
712       */
713      public boolean Define_boolean_reachable(ASTNode caller, ASTNode child) {
714        if(caller == getStmtListNoTransform())  {
715        int childIndex = caller.getIndexOfChild(child);
716        return childIndex == 0 ? reachable() : getStmt(childIndex-1).canCompleteNormally();
717      }
718        else {      return getParent().Define_boolean_reachable(this, caller);
719        }
720      }
721      /**
722       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:148
723       * @apilevel internal
724       */
725      public boolean Define_boolean_reportUnreachable(ASTNode caller, ASTNode child) {
726        if(caller == getStmtListNoTransform())  {
727        int i = caller.getIndexOfChild(child);
728        return i == 0 ? reachable() : getStmt(i-1).reachable();
729      }
730        else {      return getParent().Define_boolean_reportUnreachable(this, caller);
731        }
732      }
733      /**
734       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:44
735       * @apilevel internal
736       */
737      public int Define_int_variableScopeEndLabel(ASTNode caller, ASTNode child, CodeGeneration gen) {
738        if(caller == getStmtListNoTransform())  {
739        int i = caller.getIndexOfChild(child);
740        return variableScopeEndLabel(gen);
741      }
742        else {      return getParent().Define_int_variableScopeEndLabel(this, caller, gen);
743        }
744      }
745      /**
746       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/LocalNum.jrag:110
747       * @apilevel internal
748       */
749      public int Define_int_localNum(ASTNode caller, ASTNode child) {
750        if(caller == getStmtListNoTransform())  { 
751        int index = caller.getIndexOfChild(child);
752        {
753        if(index == 0)
754          return localNum();
755        if(getStmt(index-1) instanceof VariableDeclaration)
756          return getStmt(index-1).localNum() + ((VariableDeclaration)getStmt(index-1)).type().variableSize();
757        return getStmt(index-1).localNum();
758      }
759      }
760        else {      return getParent().Define_int_localNum(this, caller);
761        }
762      }
763      /**
764       * @apilevel internal
765       */
766      public ASTNode rewriteTo() {
767        return super.rewriteTo();
768      }
769    }