/******************************************************************************* * Copyright (c) 2000, 2003 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Common Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/cpl-v10.html * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ package net.sourceforge.phpdt.internal.core.builder; import java.util.ArrayList; import net.sourceforge.phpdt.core.IClasspathEntry; import net.sourceforge.phpdt.core.IJavaProject; import net.sourceforge.phpdt.core.JavaCore; import net.sourceforge.phpdt.core.compiler.CharOperation; import net.sourceforge.phpdt.internal.compiler.env.INameEnvironment; import net.sourceforge.phpdt.internal.compiler.env.NameEnvironmentAnswer; import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation; import net.sourceforge.phpdt.internal.core.ClasspathEntry; import net.sourceforge.phpdt.internal.core.JavaModel; import net.sourceforge.phpdt.internal.core.JavaProject; import net.sourceforge.phpdt.internal.core.util.SimpleLookupTable; import org.eclipse.core.resources.IContainer; import org.eclipse.core.resources.IFolder; import org.eclipse.core.resources.IMarker; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IWorkspaceRoot; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.Path; public class NameEnvironment implements INameEnvironment { boolean isIncrementalBuild; ClasspathMultiDirectory[] sourceLocations; //ClasspathLocation[] binaryLocations; String[] initialTypeNames; // assumed that each name is of the form "a/b/ClassName" SourceFile[] additionalUnits; NameEnvironment(IWorkspaceRoot root, JavaProject javaProject, SimpleLookupTable binaryLocationsPerProject) throws CoreException { this.isIncrementalBuild = false; // this.sourceLocations = new ClasspathMultiDirectory[0]; computeClasspathLocations(root, javaProject, binaryLocationsPerProject); setNames(null, null); } public NameEnvironment(IJavaProject javaProject) { this.isIncrementalBuild = false; try { computeClasspathLocations(javaProject.getProject().getWorkspace().getRoot(), (JavaProject) javaProject, null); } catch(CoreException e) { // this.sourceLocations = new ClasspathMultiDirectory[0]; // this.binaryLocations = new ClasspathLocation[0]; } setNames(null, null); } /* Some examples of resolved class path entries. * Remember to search class path in the order that it was defined. * * 1a. typical project with no source folders: * /Test[CPE_SOURCE][K_SOURCE] -> D:/eclipse.test/Test * 1b. project with source folders: * /Test/src1[CPE_SOURCE][K_SOURCE] -> D:/eclipse.test/Test/src1 * /Test/src2[CPE_SOURCE][K_SOURCE] -> D:/eclipse.test/Test/src2 * NOTE: These can be in any order & separated by prereq projects or libraries * 1c. project external to workspace (only detectable using getLocation()): * /Test/src[CPE_SOURCE][K_SOURCE] -> d:/eclipse.zzz/src * Need to search source folder & output folder * * 2. zip files: * D:/j9/lib/jclMax/classes.zip[CPE_LIBRARY][K_BINARY][sourcePath:d:/j9/lib/jclMax/source/source.zip] * -> D:/j9/lib/jclMax/classes.zip * ALWAYS want to take the library path as is * * 3a. prereq project (regardless of whether it has a source or output folder): * /Test[CPE_PROJECT][K_SOURCE] -> D:/eclipse.test/Test * ALWAYS want to append the output folder & ONLY search for .class files */ private void computeClasspathLocations( IWorkspaceRoot root, JavaProject javaProject, SimpleLookupTable binaryLocationsPerProject) throws CoreException { /* Update cycle marker */ IMarker cycleMarker = javaProject.getCycleMarker(); if (cycleMarker != null) { int severity = JavaCore.ERROR.equals(javaProject.getOption(JavaCore.CORE_CIRCULAR_CLASSPATH, true)) ? IMarker.SEVERITY_ERROR : IMarker.SEVERITY_WARNING; if (severity != ((Integer) cycleMarker.getAttribute(IMarker.SEVERITY)).intValue()) cycleMarker.setAttribute(IMarker.SEVERITY, severity); } /* Update incomplete classpath marker */ // IClasspathEntry[] classpathEntries = javaProject.getExpandedClasspath(true, true); IClasspathEntry[] classpathEntries = javaProject.getExpandedClasspath(true/*ignore unresolved variable*/, false/*don't create markers*/, null/*preferred cp*/, null/*preferred output*/); ArrayList sLocations = new ArrayList(classpathEntries.length); ArrayList bLocations = new ArrayList(classpathEntries.length); nextEntry : for (int i = 0, l = classpathEntries.length; i < l; i++) { ClasspathEntry entry = (ClasspathEntry) classpathEntries[i]; IPath path = entry.getPath(); Object target = JavaModel.getTarget(root, path, true); if (target == null) continue nextEntry; switch(entry.getEntryKind()) { case IClasspathEntry.CPE_SOURCE : if (!(target instanceof IContainer)) continue nextEntry; // IPath outputPath = entry.getOutputLocation() != null // ? entry.getOutputLocation() // : javaProject.getOutputLocation(); IContainer outputFolder = null; // if (outputPath.segmentCount() == 1) { // outputFolder = javaProject.getProject(); // } else { // outputFolder = root.getFolder(outputPath); // if (!outputFolder.exists()) // createFolder(outputFolder); // } sLocations.add( ClasspathLocation.forSourceFolder((IContainer) target, outputFolder, entry.fullExclusionPatternChars())); continue nextEntry; case IClasspathEntry.CPE_PROJECT : if (!(target instanceof IProject)) continue nextEntry; IProject prereqProject = (IProject) target; if (!JavaProject.hasJavaNature(prereqProject)) continue nextEntry; // if project doesn't have java nature or is not accessible JavaProject prereqJavaProject = (JavaProject) JavaCore.create(prereqProject); IClasspathEntry[] prereqClasspathEntries = prereqJavaProject.getRawClasspath(); ArrayList seen = new ArrayList(); nextPrereqEntry: for (int j = 0, m = prereqClasspathEntries.length; j < m; j++) { IClasspathEntry prereqEntry = (IClasspathEntry) prereqClasspathEntries[j]; if (prereqEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE) { Object prereqTarget = JavaModel.getTarget(root, prereqEntry.getPath(), true); if (!(prereqTarget instanceof IContainer)) continue nextPrereqEntry; IPath prereqOutputPath = prereqEntry.getOutputLocation() != null ? prereqEntry.getOutputLocation() : prereqJavaProject.getOutputLocation(); IContainer binaryFolder = prereqOutputPath.segmentCount() == 1 ? (IContainer) prereqProject : (IContainer) root.getFolder(prereqOutputPath); if (binaryFolder.exists() && !seen.contains(binaryFolder)) { seen.add(binaryFolder); ClasspathLocation bLocation = ClasspathLocation.forBinaryFolder(binaryFolder, true); bLocations.add(bLocation); if (binaryLocationsPerProject != null) { // normal builder mode ClasspathLocation[] existingLocations = (ClasspathLocation[]) binaryLocationsPerProject.get(prereqProject); if (existingLocations == null) { existingLocations = new ClasspathLocation[] {bLocation}; } else { int size = existingLocations.length; System.arraycopy(existingLocations, 0, existingLocations = new ClasspathLocation[size + 1], 0, size); existingLocations[size] = bLocation; } binaryLocationsPerProject.put(prereqProject, existingLocations); } } } } continue nextEntry; // case IClasspathEntry.CPE_LIBRARY : // if (target instanceof IResource) { // IResource resource = (IResource) target; // ClasspathLocation bLocation = null; // if (resource instanceof IFile) { // if (!(ProjectPrefUtil.isArchiveFileName(path.lastSegment()))) // continue nextEntry; // bLocation = ClasspathLocation.forLibrary((IFile) resource); // } else if (resource instanceof IContainer) { // bLocation = ClasspathLocation.forBinaryFolder((IContainer) target, false); // is library folder not output folder // } // bLocations.add(bLocation); // if (binaryLocationsPerProject != null) { // normal builder mode // IProject p = resource.getProject(); // can be the project being built // ClasspathLocation[] existingLocations = (ClasspathLocation[]) binaryLocationsPerProject.get(p); // if (existingLocations == null) { // existingLocations = new ClasspathLocation[] {bLocation}; // } else { // int size = existingLocations.length; // System.arraycopy(existingLocations, 0, existingLocations = new ClasspathLocation[size + 1], 0, size); // existingLocations[size] = bLocation; // } // binaryLocationsPerProject.put(p, existingLocations); // } // } else if (target instanceof File) { // if (!(ProjectPrefUtil.isArchiveFileName(path.lastSegment()))) // continue nextEntry; // bLocations.add(ClasspathLocation.forLibrary(path.toString())); // } // continue nextEntry; } } // now split the classpath locations... place the output folders ahead of the other .class file folders & jars ArrayList outputFolders = new ArrayList(1); this.sourceLocations = new ClasspathMultiDirectory[sLocations.size()]; if (!sLocations.isEmpty()) { sLocations.toArray(this.sourceLocations); // collect the output folders, skipping duplicates next : for (int i = 0, l = sourceLocations.length; i < l; i++) { ClasspathMultiDirectory md = sourceLocations[i]; // IPath outputPath = md.binaryFolder.getFullPath(); // for (int j = 0; j < i; j++) { // compare against previously walked source folders // if (outputPath.equals(sourceLocations[j].binaryFolder.getFullPath())) { // md.hasIndependentOutputFolder = sourceLocations[j].hasIndependentOutputFolder; // continue next; // } // } outputFolders.add(md); // also tag each source folder whose output folder is an independent folder & is not also a source folder // for (int j = 0, m = sourceLocations.length; j < m; j++) // if (outputPath.equals(sourceLocations[j].sourceFolder.getFullPath())) // continue next; md.hasIndependentOutputFolder = true; } } // combine the output folders with the binary folders & jars... place the output folders before other .class file folders & jars // this.binaryLocations = new ClasspathLocation[outputFolders.size() + bLocations.size()]; // int index = 0; // for (int i = 0, l = outputFolders.size(); i < l; i++) // this.binaryLocations[index++] = (ClasspathLocation) outputFolders.get(i); // for (int i = 0, l = bLocations.size(); i < l; i++) // this.binaryLocations[index++] = (ClasspathLocation) bLocations.get(i); } public void cleanup() { this.initialTypeNames = null; this.additionalUnits = null; for (int i = 0, l = sourceLocations.length; i < l; i++) sourceLocations[i].cleanup(); // for (int i = 0, l = binaryLocations.length; i < l; i++) // binaryLocations[i].cleanup(); } private void createFolder(IContainer folder) throws CoreException { if (!folder.exists()) { createFolder(folder.getParent()); ((IFolder) folder).create(true, true, null); } } private NameEnvironmentAnswer findClass(String qualifiedTypeName, char[] typeName) { if (initialTypeNames != null) { for (int i = 0, l = initialTypeNames.length; i < l; i++) { if (qualifiedTypeName.equals(initialTypeNames[i])) { if (isIncrementalBuild) // catch the case that a type inside a source file has been renamed but other class files are looking for it throw new AbortCompilation(true, new AbortIncrementalBuildException(qualifiedTypeName)); return null; // looking for a file which we know was provided at the beginning of the compilation } } } if (additionalUnits != null && sourceLocations.length > 0) { // if an additional source file is waiting to be compiled, answer it BUT not if this is a secondary type search // if we answer X.java & it no longer defines Y then the binary type looking for Y will think the class path is wrong // let the recompile loop fix up dependents when the secondary type Y has been deleted from X.java IPath qSourceFilePath = new Path(qualifiedTypeName + ".java"); //$NON-NLS-1$ int qSegmentCount = qSourceFilePath.segmentCount(); next : for (int i = 0, l = additionalUnits.length; i < l; i++) { SourceFile additionalUnit = additionalUnits[i]; IPath fullPath = additionalUnit.resource.getFullPath(); int prefixCount = additionalUnit.sourceLocation.sourceFolder.getFullPath().segmentCount(); if (qSegmentCount == fullPath.segmentCount() - prefixCount) { for (int j = 0; j < qSegmentCount; j++) if (!qSourceFilePath.segment(j).equals(fullPath.segment(j + prefixCount))) continue next; return new NameEnvironmentAnswer(additionalUnit); } } } // String qBinaryFileName = qualifiedTypeName + ".class"; //$NON-NLS-1$ // String binaryFileName = qBinaryFileName; // String qPackageName = ""; //$NON-NLS-1$ // if (qualifiedTypeName.length() > typeName.length) { // int typeNameStart = qBinaryFileName.length() - typeName.length - 6; // size of ".class" // qPackageName = qBinaryFileName.substring(0, typeNameStart - 1); // binaryFileName = qBinaryFileName.substring(typeNameStart); // } // // // NOTE: the output folders are added at the beginning of the binaryLocations // for (int i = 0, l = binaryLocations.length; i < l; i++) { // NameEnvironmentAnswer answer = binaryLocations[i].findClass(binaryFileName, qPackageName, qBinaryFileName); // if (answer != null) return answer; // } return null; } public NameEnvironmentAnswer findType(char[][] compoundName) { if (compoundName != null) return findClass(new String(CharOperation.concatWith(compoundName, '/')), compoundName[compoundName.length - 1]); return null; } public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName) { if (typeName != null) return findClass(new String(CharOperation.concatWith(packageName, typeName, '/')), typeName); return null; } public boolean isPackage(char[][] compoundName, char[] packageName) { return isPackage(new String(CharOperation.concatWith(compoundName, packageName, '/'))); } public boolean isPackage(String qualifiedPackageName) { // NOTE: the output folders are added at the beginning of the binaryLocations // for (int i = 0, l = binaryLocations.length; i < l; i++) // if (binaryLocations[i].isPackage(qualifiedPackageName)) // return true; return false; } void setNames(String[] initialTypeNames, SourceFile[] additionalUnits) { this.initialTypeNames = initialTypeNames; this.additionalUnits = additionalUnits; for (int i = 0, l = sourceLocations.length; i < l; i++) sourceLocations[i].reset(); // for (int i = 0, l = binaryLocations.length; i < l; i++) // binaryLocations[i].reset(); } }