e023b597104222131cc2db85f8d018d97ed3e1bc
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / core / builder / NameEnvironment.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.core.builder;
12
13 import java.util.ArrayList;
14
15 import net.sourceforge.phpdt.core.IClasspathEntry;
16 import net.sourceforge.phpdt.core.IJavaProject;
17 import net.sourceforge.phpdt.core.JavaCore;
18 import net.sourceforge.phpdt.core.compiler.CharOperation;
19 import net.sourceforge.phpdt.internal.compiler.env.INameEnvironment;
20 import net.sourceforge.phpdt.internal.compiler.env.NameEnvironmentAnswer;
21 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
22 import net.sourceforge.phpdt.internal.core.ClasspathEntry;
23 import net.sourceforge.phpdt.internal.core.JavaModel;
24 import net.sourceforge.phpdt.internal.core.JavaProject;
25 import net.sourceforge.phpdt.internal.core.util.SimpleLookupTable;
26
27 import org.eclipse.core.resources.IContainer;
28 import org.eclipse.core.resources.IFolder;
29 import org.eclipse.core.resources.IMarker;
30 import org.eclipse.core.resources.IProject;
31 import org.eclipse.core.resources.IWorkspaceRoot;
32 import org.eclipse.core.runtime.CoreException;
33 import org.eclipse.core.runtime.IPath;
34 import org.eclipse.core.runtime.Path;
35
36 public class NameEnvironment implements INameEnvironment {
37
38   boolean isIncrementalBuild;
39   ClasspathMultiDirectory[] sourceLocations;
40   //ClasspathLocation[] binaryLocations;
41
42   String[] initialTypeNames; // assumed that each name is of the form "a/b/ClassName"
43   SourceFile[] additionalUnits;
44
45   NameEnvironment(IWorkspaceRoot root, JavaProject javaProject, SimpleLookupTable binaryLocationsPerProject) throws CoreException {
46     this.isIncrementalBuild = false;
47 //    this.sourceLocations = new ClasspathMultiDirectory[0];
48     computeClasspathLocations(root, javaProject, binaryLocationsPerProject);
49     setNames(null, null);
50   }
51
52   public NameEnvironment(IJavaProject javaProject) {
53     this.isIncrementalBuild = false;
54         try {
55                 computeClasspathLocations(javaProject.getProject().getWorkspace().getRoot(), (JavaProject) javaProject, null);
56         } catch(CoreException e) {
57 //    this.sourceLocations = new ClasspathMultiDirectory[0];
58     //          this.binaryLocations = new ClasspathLocation[0];
59         }
60     setNames(null, null);
61   }
62
63   /* Some examples of resolved class path entries.
64   * Remember to search class path in the order that it was defined.
65   *
66   * 1a. typical project with no source folders:
67   *   /Test[CPE_SOURCE][K_SOURCE] -> D:/eclipse.test/Test
68   * 1b. project with source folders:
69   *   /Test/src1[CPE_SOURCE][K_SOURCE] -> D:/eclipse.test/Test/src1
70   *   /Test/src2[CPE_SOURCE][K_SOURCE] -> D:/eclipse.test/Test/src2
71   *  NOTE: These can be in any order & separated by prereq projects or libraries
72   * 1c. project external to workspace (only detectable using getLocation()):
73   *   /Test/src[CPE_SOURCE][K_SOURCE] -> d:/eclipse.zzz/src
74   *  Need to search source folder & output folder
75   *
76   * 2. zip files:
77   *   D:/j9/lib/jclMax/classes.zip[CPE_LIBRARY][K_BINARY][sourcePath:d:/j9/lib/jclMax/source/source.zip]
78   *      -> D:/j9/lib/jclMax/classes.zip
79   *  ALWAYS want to take the library path as is
80   *
81   * 3a. prereq project (regardless of whether it has a source or output folder):
82   *   /Test[CPE_PROJECT][K_SOURCE] -> D:/eclipse.test/Test
83   *  ALWAYS want to append the output folder & ONLY search for .class files
84   */
85   private void computeClasspathLocations(
86         IWorkspaceRoot root,
87         JavaProject javaProject,
88         SimpleLookupTable binaryLocationsPerProject) throws CoreException {
89   
90         /* Update incomplete classpath marker */
91         IClasspathEntry[] classpathEntries = javaProject.getExpandedClasspath(true, true);
92   
93         /* Update cycle marker */
94         IMarker cycleMarker = javaProject.getCycleMarker();
95         if (cycleMarker != null) {
96                 int severity = JavaCore.ERROR.equals(javaProject.getOption(JavaCore.CORE_CIRCULAR_CLASSPATH, true))
97                         ? IMarker.SEVERITY_ERROR
98                         : IMarker.SEVERITY_WARNING;
99                 if (severity != ((Integer) cycleMarker.getAttribute(IMarker.SEVERITY)).intValue())
100                         cycleMarker.setAttribute(IMarker.SEVERITY, severity);
101         }
102   
103         ArrayList sLocations = new ArrayList(classpathEntries.length);
104         ArrayList bLocations = new ArrayList(classpathEntries.length);
105         nextEntry : for (int i = 0, l = classpathEntries.length; i < l; i++) {
106                 ClasspathEntry entry = (ClasspathEntry) classpathEntries[i];
107                 IPath path = entry.getPath();
108                 Object target = JavaModel.getTarget(root, path, true);
109                 if (target == null) continue nextEntry;
110   
111                 switch(entry.getEntryKind()) {
112                         case IClasspathEntry.CPE_SOURCE :
113                                 if (!(target instanceof IContainer)) continue nextEntry;
114 //                              IPath outputPath = entry.getOutputLocation() != null 
115 //                                      ? entry.getOutputLocation() 
116 //                                      : javaProject.getOutputLocation();
117                                 IContainer outputFolder = null;
118 //                              if (outputPath.segmentCount() == 1) {
119 //                                      outputFolder = javaProject.getProject();
120 //                              } else {
121 //                                      outputFolder = root.getFolder(outputPath);
122 //                                      if (!outputFolder.exists())
123 //                                              createFolder(outputFolder);
124 //                              }
125                                 sLocations.add(
126                                         ClasspathLocation.forSourceFolder((IContainer) target, outputFolder, entry.fullExclusionPatternChars()));
127                                 continue nextEntry;
128   
129                         case IClasspathEntry.CPE_PROJECT :
130                                 if (!(target instanceof IProject)) continue nextEntry;
131                                 IProject prereqProject = (IProject) target;
132                                 if (!JavaProject.hasJavaNature(prereqProject)) continue nextEntry; // if project doesn't have java nature or is not accessible
133   
134                                 JavaProject prereqJavaProject = (JavaProject) JavaCore.create(prereqProject);
135                                 IClasspathEntry[] prereqClasspathEntries = prereqJavaProject.getRawClasspath();
136                                 ArrayList seen = new ArrayList();
137                                 nextPrereqEntry: for (int j = 0, m = prereqClasspathEntries.length; j < m; j++) {
138                                         IClasspathEntry prereqEntry = (IClasspathEntry) prereqClasspathEntries[j];
139                                         if (prereqEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
140                                                 Object prereqTarget = JavaModel.getTarget(root, prereqEntry.getPath(), true);
141                                                 if (!(prereqTarget instanceof IContainer)) continue nextPrereqEntry;
142                                                 IPath prereqOutputPath = prereqEntry.getOutputLocation() != null 
143                                                         ? prereqEntry.getOutputLocation() 
144                                                         : prereqJavaProject.getOutputLocation();
145                                                 IContainer binaryFolder = prereqOutputPath.segmentCount() == 1
146                                                         ? (IContainer) prereqProject
147                                                         : (IContainer) root.getFolder(prereqOutputPath);
148                                                 if (binaryFolder.exists() && !seen.contains(binaryFolder)) {
149                                                         seen.add(binaryFolder);
150                                                         ClasspathLocation bLocation = ClasspathLocation.forBinaryFolder(binaryFolder, true);
151                                                         bLocations.add(bLocation);
152                                                         if (binaryLocationsPerProject != null) { // normal builder mode
153                                                                 ClasspathLocation[] existingLocations = (ClasspathLocation[]) binaryLocationsPerProject.get(prereqProject);
154                                                                 if (existingLocations == null) {
155                                                                         existingLocations = new ClasspathLocation[] {bLocation};
156                                                                 } else {
157                                                                         int size = existingLocations.length;
158                                                                         System.arraycopy(existingLocations, 0, existingLocations = new ClasspathLocation[size + 1], 0, size);
159                                                                         existingLocations[size] = bLocation;
160                                                                 }
161                                                                 binaryLocationsPerProject.put(prereqProject, existingLocations);
162                                                         }
163                                                 }
164                                         }
165                                 }
166                                 continue nextEntry;
167   
168 //                      case IClasspathEntry.CPE_LIBRARY :
169 //                              if (target instanceof IResource) {
170 //                                      IResource resource = (IResource) target;
171 //                                      ClasspathLocation bLocation = null;
172 //                                      if (resource instanceof IFile) {
173 //                                              if (!(Util.isArchiveFileName(path.lastSegment())))
174 //                                                      continue nextEntry;
175 //                                              bLocation = ClasspathLocation.forLibrary((IFile) resource);
176 //                                      } else if (resource instanceof IContainer) {
177 //                                              bLocation = ClasspathLocation.forBinaryFolder((IContainer) target, false); // is library folder not output folder
178 //                                      }
179 //                                      bLocations.add(bLocation);
180 //                                      if (binaryLocationsPerProject != null) { // normal builder mode
181 //                                              IProject p = resource.getProject(); // can be the project being built
182 //                                              ClasspathLocation[] existingLocations = (ClasspathLocation[]) binaryLocationsPerProject.get(p);
183 //                                              if (existingLocations == null) {
184 //                                                      existingLocations = new ClasspathLocation[] {bLocation};
185 //                                              } else {
186 //                                                      int size = existingLocations.length;
187 //                                                      System.arraycopy(existingLocations, 0, existingLocations = new ClasspathLocation[size + 1], 0, size);
188 //                                                      existingLocations[size] = bLocation;
189 //                                              }
190 //                                              binaryLocationsPerProject.put(p, existingLocations);
191 //                                      }
192 //                              } else if (target instanceof File) {
193 //                                      if (!(Util.isArchiveFileName(path.lastSegment())))
194 //                                              continue nextEntry;
195 //                                      bLocations.add(ClasspathLocation.forLibrary(path.toString()));
196 //                              }
197 //                              continue nextEntry;
198                 }
199         }
200   
201         // now split the classpath locations... place the output folders ahead of the other .class file folders & jars
202         ArrayList outputFolders = new ArrayList(1);
203         this.sourceLocations = new ClasspathMultiDirectory[sLocations.size()];
204         if (!sLocations.isEmpty()) {
205                 sLocations.toArray(this.sourceLocations);
206   
207                 // collect the output folders, skipping duplicates
208                 next : for (int i = 0, l = sourceLocations.length; i < l; i++) {
209                         ClasspathMultiDirectory md = sourceLocations[i];
210 //                      IPath outputPath = md.binaryFolder.getFullPath();
211 //                      for (int j = 0; j < i; j++) { // compare against previously walked source folders
212 //                              if (outputPath.equals(sourceLocations[j].binaryFolder.getFullPath())) {
213 //                                      md.hasIndependentOutputFolder = sourceLocations[j].hasIndependentOutputFolder;
214 //                                      continue next;
215 //                              }
216 //                      }
217                         outputFolders.add(md);
218   
219                         // also tag each source folder whose output folder is an independent folder & is not also a source folder
220 //                      for (int j = 0, m = sourceLocations.length; j < m; j++)
221 //                              if (outputPath.equals(sourceLocations[j].sourceFolder.getFullPath()))
222 //                                      continue next;
223                         md.hasIndependentOutputFolder = true;
224                 }
225         }
226
227 //   combine the output folders with the binary folders & jars... place the output folders before other .class file folders & jars
228 //      this.binaryLocations = new ClasspathLocation[outputFolders.size() + bLocations.size()];
229 //      int index = 0;
230 //      for (int i = 0, l = outputFolders.size(); i < l; i++)
231 //              this.binaryLocations[index++] = (ClasspathLocation) outputFolders.get(i);
232 //      for (int i = 0, l = bLocations.size(); i < l; i++)
233 //              this.binaryLocations[index++] = (ClasspathLocation) bLocations.get(i);
234   }
235
236   public void cleanup() {
237     this.initialTypeNames = null;
238     this.additionalUnits = null;
239     for (int i = 0, l = sourceLocations.length; i < l; i++)
240       sourceLocations[i].cleanup();
241     //  for (int i = 0, l = binaryLocations.length; i < l; i++)
242     //          binaryLocations[i].cleanup();
243   }
244
245   private void createFolder(IContainer folder) throws CoreException {
246     if (!folder.exists()) {
247       createFolder(folder.getParent());
248       ((IFolder) folder).create(true, true, null);
249     }
250   }
251
252   private NameEnvironmentAnswer findClass(String qualifiedTypeName, char[] typeName) {
253     if (initialTypeNames != null) {
254       for (int i = 0, l = initialTypeNames.length; i < l; i++) {
255         if (qualifiedTypeName.equals(initialTypeNames[i])) {
256           if (isIncrementalBuild)
257             // catch the case that a type inside a source file has been renamed but other class files are looking for it
258             throw new AbortCompilation(true, new AbortIncrementalBuildException(qualifiedTypeName));
259           return null; // looking for a file which we know was provided at the beginning of the compilation
260         }
261       }
262     }
263
264     if (additionalUnits != null && sourceLocations.length > 0) {
265       // if an additional source file is waiting to be compiled, answer it BUT not if this is a secondary type search
266       // if we answer X.java & it no longer defines Y then the binary type looking for Y will think the class path is wrong
267       // let the recompile loop fix up dependents when the secondary type Y has been deleted from X.java
268       IPath qSourceFilePath = new Path(qualifiedTypeName + ".java"); //$NON-NLS-1$
269       int qSegmentCount = qSourceFilePath.segmentCount();
270       next : for (int i = 0, l = additionalUnits.length; i < l; i++) {
271         SourceFile additionalUnit = additionalUnits[i];
272         IPath fullPath = additionalUnit.resource.getFullPath();
273         int prefixCount = additionalUnit.sourceLocation.sourceFolder.getFullPath().segmentCount();
274         if (qSegmentCount == fullPath.segmentCount() - prefixCount) {
275           for (int j = 0; j < qSegmentCount; j++)
276             if (!qSourceFilePath.segment(j).equals(fullPath.segment(j + prefixCount)))
277               continue next;
278           return new NameEnvironmentAnswer(additionalUnit);
279         }
280       }
281     }
282
283     //  String qBinaryFileName = qualifiedTypeName + ".class"; //$NON-NLS-1$
284     //  String binaryFileName = qBinaryFileName;
285     //  String qPackageName =  ""; //$NON-NLS-1$
286     //  if (qualifiedTypeName.length() > typeName.length) {
287     //          int typeNameStart = qBinaryFileName.length() - typeName.length - 6; // size of ".class"
288     //          qPackageName =  qBinaryFileName.substring(0, typeNameStart - 1);
289     //          binaryFileName = qBinaryFileName.substring(typeNameStart);
290     //  }
291     //
292     //  // NOTE: the output folders are added at the beginning of the binaryLocations
293     //  for (int i = 0, l = binaryLocations.length; i < l; i++) {
294     //          NameEnvironmentAnswer answer = binaryLocations[i].findClass(binaryFileName, qPackageName, qBinaryFileName);
295     //          if (answer != null) return answer;
296     //  }
297     return null;
298   }
299
300   public NameEnvironmentAnswer findType(char[][] compoundName) {
301     if (compoundName != null)
302       return findClass(new String(CharOperation.concatWith(compoundName, '/')), compoundName[compoundName.length - 1]);
303     return null;
304   }
305
306   public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName) {
307     if (typeName != null)
308       return findClass(new String(CharOperation.concatWith(packageName, typeName, '/')), typeName);
309     return null;
310   }
311
312   public boolean isPackage(char[][] compoundName, char[] packageName) {
313     return isPackage(new String(CharOperation.concatWith(compoundName, packageName, '/')));
314   }
315
316   public boolean isPackage(String qualifiedPackageName) {
317     // NOTE: the output folders are added at the beginning of the binaryLocations
318     //  for (int i = 0, l = binaryLocations.length; i < l; i++)
319     //          if (binaryLocations[i].isPackage(qualifiedPackageName))
320     //                  return true;
321     return false;
322   }
323
324   void setNames(String[] initialTypeNames, SourceFile[] additionalUnits) {
325     this.initialTypeNames = initialTypeNames;
326     this.additionalUnits = additionalUnits;
327     for (int i = 0, l = sourceLocations.length; i < l; i++)
328       sourceLocations[i].reset();
329     //  for (int i = 0, l = binaryLocations.length; i < l; i++)
330     //          binaryLocations[i].reset();
331   }
332 }