remove dependency to internal package
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / CompilationUnitDeclaration.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler.ast;
12 import java.util.ArrayList;
13
14 import net.sourceforge.phpdt.core.compiler.CharOperation;
15 import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
16 import net.sourceforge.phpdt.internal.compiler.CompilationResult;
17 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
18 import net.sourceforge.phpdt.internal.compiler.lookup.CompilationUnitScope;
19 import net.sourceforge.phpdt.internal.compiler.lookup.LocalTypeBinding;
20 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilationUnit;
21 import net.sourceforge.phpdt.internal.compiler.problem.AbortMethod;
22 import net.sourceforge.phpdt.internal.compiler.problem.AbortType;
23 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
24 import net.sourceforge.phpdt.internal.compiler.problem.ProblemSeverities;
25
26 public class CompilationUnitDeclaration extends ASTNode implements ProblemSeverities, ReferenceContext {
27
28   public ImportReference currentPackage;
29   public ImportReference[] imports;
30   //  public TypeDeclaration[] types;
31   public ArrayList types;
32   
33   //public char[][] name;
34   public int[][] comments;
35
36   public boolean ignoreFurtherInvestigation = false; // once pointless to investigate due to errors
37   public boolean ignoreMethodBodies = false;
38   public CompilationUnitScope scope;
39   public ProblemReporter problemReporter;
40   public CompilationResult compilationResult;
41
42   private LocalTypeBinding[] localTypes;
43   int localTypeCount = 0;
44
45   public boolean isPropagatingInnerClassEmulation;
46
47   public CompilationUnitDeclaration(ProblemReporter problemReporter, CompilationResult compilationResult, int sourceLength) {
48
49     this.problemReporter = problemReporter;
50     this.compilationResult = compilationResult;
51     this.types = new ArrayList();
52     //by definition of a compilation unit....
53     sourceStart = 0;
54     sourceEnd = sourceLength - 1;
55   }
56
57   /*
58    *    We cause the compilation task to abort to a given extent.
59    */
60   public void abort(int abortLevel) {
61
62     switch (abortLevel) {
63       case AbortType :
64         throw new AbortType(compilationResult);
65       case AbortMethod :
66         throw new AbortMethod(compilationResult);
67       default :
68         throw new AbortCompilationUnit(compilationResult);
69     }
70   }
71
72   /*
73    * Dispatch code analysis AND request saturation of inner emulation
74    */
75   public void analyseCode() {
76
77     if (ignoreFurtherInvestigation)
78       return;
79     try {
80       if (types != null) {
81         for (int i = 0, count = types.size(); i < count; i++) {
82           if (types.get(i) instanceof TypeDeclaration)
83              ((TypeDeclaration) types.get(i)).analyseCode(scope);
84         }
85       }
86       // request inner emulation propagation
87       propagateInnerEmulationForAllLocalTypes();
88     } catch (AbortCompilationUnit e) {
89       this.ignoreFurtherInvestigation = true;
90       return;
91     }
92   }
93
94   /*
95    * When unit result is about to be accepted, removed back pointers
96    * to compiler structures.
97    */
98   public void cleanUp() {
99     if (this.types != null) {
100       for (int i = 0, max = this.types.size(); i < max; i++) {
101         if (this.types.get(i) instanceof TypeDeclaration) {
102           cleanUp((TypeDeclaration) this.types.get(i));
103         }
104       }
105       for (int i = 0, max = this.localTypeCount; i < max; i++) {
106         // null out the type's scope backpointers
107         localTypes[i].scope = null; // local members are already in the list
108       }
109     }
110     //          ClassFile[] classFiles = compilationResult.getClassFiles();
111     //          for (int i = 0, max = classFiles.length; i < max; i++) {
112     //                  // clear the classFile back pointer to the bindings
113     //                  ClassFile classFile = classFiles[i];
114     //                  // null out the classfile backpointer to a type binding
115     //                  classFile.referenceBinding = null;
116     //                  classFile.codeStream = null; // codeStream holds onto ast and scopes
117     //                  classFile.innerClassesBindings = null;
118     //          }
119   }
120   private void cleanUp(TypeDeclaration type) {
121     if (type.memberTypes != null) {
122       for (int i = 0, max = type.memberTypes.length; i < max; i++) {
123         cleanUp(type.memberTypes[i]);
124       }
125     }
126     if (type.binding != null) {
127       // null out the type's scope backpointers
128       type.binding.scope = null;
129     }
130   }
131
132 //  public void checkUnusedImports() {
133 //
134 //    if (this.scope.imports != null) {
135 //      for (int i = 0, max = this.scope.imports.length; i < max; i++) {
136 //        ImportBinding importBinding = this.scope.imports[i];
137 //        ImportReference importReference = importBinding.reference;
138 //        if (importReference != null && !importReference.used) {
139 //          scope.problemReporter().unusedImport(importReference);
140 //        }
141 //      }
142 //    }
143 //  }
144
145   public CompilationResult compilationResult() {
146     return compilationResult;
147   }
148
149   /*
150    * Finds the matching type amoung this compilation unit types.
151    * Returns null if no type with this name is found.
152    * The type name is a compound name
153    * eg. if we're looking for X.A.B then a type name would be {X, A, B}
154    */
155   public TypeDeclaration declarationOfType(char[][] typeName) {
156
157     for (int i = 0; i < this.types.size(); i++) {
158       if (this.types.get(i) instanceof TypeDeclaration) {
159         TypeDeclaration typeDecl = ((TypeDeclaration) this.types.get(i)).declarationOfType(typeName);
160         if (typeDecl != null) {
161           return typeDecl;
162         }
163       }
164     }
165     return null;
166   }
167
168   /**
169    * Bytecode generation
170    */
171   //    public void generateCode() {
172   //
173   //            if (ignoreFurtherInvestigation) {
174   //                    if (types != null) {
175   //                            for (int i = 0, count = types.length; i < count; i++) {
176   //                                    types[i].ignoreFurtherInvestigation = true;
177   //                                    // propagate the flag to request problem type creation
178   //                                    types[i].generateCode(scope);
179   //                            }
180   //                    }
181   //                    return;
182   //            }
183   //            try {
184   //                    if (types != null) {
185   //                            for (int i = 0, count = types.length; i < count; i++)
186   //                                    types[i].generateCode(scope);
187   //                    }
188   //            } catch (AbortCompilationUnit e) {
189   //            }
190   //    }
191
192   public char[] getFileName() {
193
194     return compilationResult.getFileName();
195   }
196
197   public char[] getMainTypeName() {
198
199     if (compilationResult.compilationUnit == null) {
200       char[] fileName = compilationResult.getFileName();
201
202       int start = CharOperation.lastIndexOf('/', fileName) + 1;
203       if (start == 0 || start < CharOperation.lastIndexOf('\\', fileName))
204         start = CharOperation.lastIndexOf('\\', fileName) + 1;
205
206       int end = CharOperation.lastIndexOf('.', fileName);
207       if (end == -1)
208         end = fileName.length;
209
210       return CharOperation.subarray(fileName, start, end);
211     } else {
212       return compilationResult.compilationUnit.getMainTypeName();
213     }
214   }
215
216   public boolean isEmpty() {
217
218     return (currentPackage == null) && (imports == null) && (types == null);
219   }
220
221   public boolean hasErrors() {
222     return this.ignoreFurtherInvestigation;
223   }
224         public StringBuffer print(int indent, StringBuffer output) {
225
226                 if (currentPackage != null) {
227                         printIndent(indent, output).append("package "); //$NON-NLS-1$
228                         currentPackage.print(0, output, false).append(";\n"); //$NON-NLS-1$
229                 }
230                 if (imports != null)
231                         for (int i = 0; i < imports.length; i++) {
232                                 printIndent(indent, output).append("import "); //$NON-NLS-1$
233                                 imports[i].print(0, output).append(";\n"); //$NON-NLS-1$ 
234                         }
235
236                 if (types != null) {
237                         for (int i = 0; i < types.size(); i++) {
238                                 ((ASTNode)types.get(i)).print(indent, output).append("\n"); //$NON-NLS-1$
239                         }
240                 }
241                 return output;
242         }
243         
244   /*
245    * Force inner local types to update their innerclass emulation
246    */
247   public void propagateInnerEmulationForAllLocalTypes() {
248
249     isPropagatingInnerClassEmulation = true;
250     for (int i = 0, max = this.localTypeCount; i < max; i++) {
251
252       LocalTypeBinding localType = localTypes[i];
253       // only propagate for reachable local types
254       if ((localType.scope.referenceType().bits & IsReachableMASK) != 0) {
255         localType.updateInnerEmulationDependents();
256       }
257     }
258   }
259
260   /*
261    * Keep track of all local types, so as to update their innerclass
262    * emulation later on.
263    */
264   public void record(LocalTypeBinding localType) {
265
266     if (this.localTypeCount == 0) {
267       this.localTypes = new LocalTypeBinding[5];
268     } else if (this.localTypeCount == this.localTypes.length) {
269       System.arraycopy(
270         this.localTypes,
271         0,
272         (this.localTypes = new LocalTypeBinding[this.localTypeCount * 2]),
273         0,
274         this.localTypeCount);
275     }
276     this.localTypes[this.localTypeCount++] = localType;
277   }
278
279   public void resolve() {
280
281     try {
282       if (types != null) {
283         for (int i = 0, count = types.size(); i < count; i++) {
284           if (types.get(i) instanceof TypeDeclaration) {
285             ((TypeDeclaration) types.get(i)).resolve(scope);
286           }
287         }
288       }
289 //      if (!this.compilationResult.hasSyntaxError())
290 //        checkUnusedImports();
291     } catch (AbortCompilationUnit e) {
292       this.ignoreFurtherInvestigation = true;
293       return;
294     }
295   }
296
297   public void tagAsHavingErrors() {
298     ignoreFurtherInvestigation = true;
299   }
300
301   public String toString(int tab) {
302
303     String s = ""; //$NON-NLS-1$
304     if (currentPackage != null)
305       s = tabString(tab) + "package " + currentPackage.toString(0, false) + ";\n"; //$NON-NLS-1$ //$NON-NLS-2$
306
307     if (imports != null)
308       for (int i = 0; i < imports.length; i++) {
309         s += tabString(tab) + "include " + imports[i].toString() + ";\n"; //$NON-NLS-1$ //$NON-NLS-2$
310       };
311
312     if (types != null)
313       for (int i = 0; i < types.size(); i++) {
314         s += ((ASTNode) types.get(i)).toString(tab) + "\n"; //$NON-NLS-1$
315       }
316     return s;
317   }
318
319   public void traverse(ASTVisitor visitor, CompilationUnitScope scope) {
320
321     if (ignoreFurtherInvestigation)
322       return;
323     try {
324       if (visitor.visit(this, scope)) {
325         if (currentPackage != null) {
326           currentPackage.traverse(visitor, scope);
327         }
328         if (imports != null) {
329           int importLength = imports.length;
330           for (int i = 0; i < importLength; i++) {
331             imports[i].traverse(visitor, scope);
332           }
333         }
334         if (types != null) {
335           int typesLength = types.size();
336           for (int i = 0; i < typesLength; i++) {
337             if (types.get(i) instanceof TypeDeclaration) {
338               ((TypeDeclaration) types.get(i)).traverse(visitor, scope);
339             }
340           }
341         }
342       }
343       visitor.endVisit(this, scope);
344     } catch (AbortCompilationUnit e) {
345     }
346   }
347 }