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