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 Dot : {@link AbstractDot};
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:17
017     */
018    public class Dot extends AbstractDot 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 Dot clone() throws CloneNotSupportedException {
034        Dot node = (Dot)super.clone();
035        node.in$Circle(false);
036        node.is$Final(false);
037        return node;
038      }
039    /**
040     * @apilevel internal
041     */
042      @SuppressWarnings({"unchecked", "cast"})
043    public Dot copy() {
044      
045      try {
046        Dot node = (Dot) clone();
047        node.parent = null;
048        if(children != null)
049          node.children = (ASTNode[]) children.clone();
050        
051        return node;
052      } catch (CloneNotSupportedException e) {
053        throw new Error("Error: clone not supported for " + getClass().getName());
054      }
055      
056    }/**
057     * Create a deep copy of the AST subtree at this node.
058     * The copy is dangling, i.e. has no parent.
059     * @return dangling copy of the subtree at this node
060     * @apilevel low-level
061     */
062      @SuppressWarnings({"unchecked", "cast"})
063    public Dot fullCopy() {
064      
065      Dot tree = (Dot) copy();
066      if (children != null) {
067        for (int i = 0; i < children.length; ++i) {
068          
069          ASTNode child = (ASTNode) children[i];
070          if(child != null) {
071            child = child.fullCopy();
072            tree.setChild(child, i);
073          }
074        }
075      }
076      return tree;
077      
078    }  /**
079       * @ast method 
080       * @aspect QualifiedNames
081       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:99
082       */
083      public Dot lastDot() {
084        Dot node = this;
085        while(node.getRightNoTransform() instanceof Dot)
086          node = (Dot)node.getRightNoTransform();
087        return node;
088      }
089      /**
090       * @ast method 
091       * @aspect QualifiedNames
092       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:113
093       */
094      public Dot qualifiesAccess(Access access) {
095          Dot lastDot = lastDot();
096          Expr l = lastDot.getRightNoTransform();
097          Dot dot = new Dot(lastDot.getRightNoTransform(), access);
098          dot.setStart(l.getStart());
099          dot.setEnd(access.getEnd());
100         lastDot.setRight(dot);
101         return this;
102      }
103      /**
104       * @ast method 
105       * @aspect QualifiedNames
106       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:124
107       */
108      private Access qualifyTailWith(Access expr) {
109        if(getRight/*NoTransform*/() instanceof AbstractDot) {
110          AbstractDot dot = (AbstractDot)getRight/*NoTransform*/();
111          return expr.qualifiesAccess(dot.getRight/*NoTransform*/());
112        }
113        return expr;
114      }
115      /**
116       * @ast method 
117       * @aspect QualifiedNames
118       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:141
119       */
120      public Access extractLast() {
121        return lastDot().getRightNoTransform();
122      }
123      /**
124       * @ast method 
125       * @aspect QualifiedNames
126       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:144
127       */
128      public void replaceLast(Access access) {
129        lastDot().setRight(access);
130      }
131      /**
132       * @ast method 
133       * 
134       */
135      public Dot() {
136        super();
137    
138    
139      }
140      /**
141       * Initializes the child array to the correct size.
142       * Initializes List and Opt nta children.
143       * @apilevel internal
144       * @ast method
145       * @ast method 
146       * 
147       */
148      public void init$Children() {
149        children = new ASTNode[2];
150      }
151      /**
152       * @ast method 
153       * 
154       */
155      public Dot(Expr p0, Access p1) {
156        setChild(p0, 0);
157        setChild(p1, 1);
158      }
159      /**
160       * @apilevel low-level
161       * @ast method 
162       * 
163       */
164      protected int numChildren() {
165        return 2;
166      }
167      /**
168       * @apilevel internal
169       * @ast method 
170       * 
171       */
172      public boolean mayHaveRewrite() {
173        return true;
174      }
175      /**
176       * Replaces the Left child.
177       * @param node The new node to replace the Left child.
178       * @apilevel high-level
179       * @ast method 
180       * 
181       */
182      public void setLeft(Expr node) {
183        setChild(node, 0);
184      }
185      /**
186       * Retrieves the Left child.
187       * @return The current node used as the Left child.
188       * @apilevel high-level
189       * @ast method 
190       * 
191       */
192      public Expr getLeft() {
193        return (Expr)getChild(0);
194      }
195      /**
196       * Retrieves the Left child.
197       * <p><em>This method does not invoke AST transformations.</em></p>
198       * @return The current node used as the Left child.
199       * @apilevel low-level
200       * @ast method 
201       * 
202       */
203      public Expr getLeftNoTransform() {
204        return (Expr)getChildNoTransform(0);
205      }
206      /**
207       * Replaces the Right child.
208       * @param node The new node to replace the Right child.
209       * @apilevel high-level
210       * @ast method 
211       * 
212       */
213      public void setRight(Access node) {
214        setChild(node, 1);
215      }
216      /**
217       * Retrieves the Right child.
218       * @return The current node used as the Right child.
219       * @apilevel high-level
220       * @ast method 
221       * 
222       */
223      public Access getRight() {
224        return (Access)getChild(1);
225      }
226      /**
227       * Retrieves the Right child.
228       * <p><em>This method does not invoke AST transformations.</em></p>
229       * @return The current node used as the Right child.
230       * @apilevel low-level
231       * @ast method 
232       * 
233       */
234      public Access getRightNoTransform() {
235        return (Access)getChildNoTransform(1);
236      }
237      /**
238       * @apilevel internal
239       */
240      public ASTNode rewriteTo() {
241        // Declared in /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag at line 210
242        if(!duringSyntacticClassification() && leftSide().isPackageAccess() && rightSide().isPackageAccess()) {
243          state().duringNameResolution++;
244          ASTNode result = rewriteRule0();
245          state().duringNameResolution--;
246          return result;
247        }
248    
249        // Declared in /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag at line 222
250        if(!duringSyntacticClassification() && leftSide().isPackageAccess() && !((Access)leftSide()).hasPrevExpr() && rightSide() instanceof TypeAccess) {
251          state().duringNameResolution++;
252          ASTNode result = rewriteRule1();
253          state().duringNameResolution--;
254          return result;
255        }
256    
257        return super.rewriteTo();
258      }
259      /**
260       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:210
261       * @apilevel internal
262       */  private Access rewriteRule0() {
263    {
264          PackageAccess left = (PackageAccess)leftSide();
265          PackageAccess right = (PackageAccess)rightSide();
266          left.setPackage(left.getPackage() + "." + right.getPackage());
267          left.setEnd(right.end());
268          return qualifyTailWith(left);
269        }  }
270      /**
271       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:222
272       * @apilevel internal
273       */  private Access rewriteRule1() {
274    {
275          PackageAccess left = (PackageAccess)leftSide();
276          TypeAccess right = (TypeAccess)rightSide();
277          right.setPackage(left.getPackage());
278          right.setStart(left.start());
279          return qualifyTailWith(right);
280        }  }
281    }