+ * This validation is intended to anticipate classpath issues prior to assigning it to a project. In particular, it will automatically + * be performed during the classpath setting operation (if validation fails, the classpath setting will not complete). + *
+ * @param javaProject the given java project
+ * @param rawClasspath a given classpath
+ * @param projectOutputLocation a given output location
+ * @return a status object with code IStatus.OK if
+ * the given classpath and output location are compatible, otherwise a status
+ * object indicating what is wrong with the classpath or output location
+ */
+ public static IJavaModelStatus validateClasspath(IJavaProject javaProject, IClasspathEntry[] rawClasspath, IPath projectOutputLocation) {
+
+ IProject project = javaProject.getProject();
+ IPath projectPath= project.getFullPath();
+ String projectName = javaProject.getElementName();
+
+ /* validate output location */
+ if (projectOutputLocation == null) {
+ return new JavaModelStatus(IJavaModelStatusConstants.NULL_PATH);
+ }
+ if (projectOutputLocation.isAbsolute()) {
+ if (!projectPath.isPrefixOf(projectOutputLocation)) {
+ return new JavaModelStatus(IJavaModelStatusConstants.PATH_OUTSIDE_PROJECT, javaProject, projectOutputLocation.toString());
+ }
+ } else {
+ return new JavaModelStatus(IJavaModelStatusConstants.RELATIVE_PATH, projectOutputLocation);
+ }
+
+ boolean hasSource = false;
+ boolean hasLibFolder = false;
+
+
+ // tolerate null path, it will be reset to default
+ if (rawClasspath == null)
+ return JavaModelStatus.VERIFIED_OK;
+
+ // retrieve resolved classpath
+ IClasspathEntry[] classpath;
+ try {
+ classpath = ((JavaProject)javaProject).getResolvedClasspath(rawClasspath, null /*output*/, true/*ignore pb*/, false/*no marker*/, null /*no reverse map*/);
+ } catch(JavaModelException e){
+ return e.getJavaModelStatus();
+ }
+ int length = classpath.length;
+
+ int outputCount = 1;
+ IPath[] outputLocations = new IPath[length+1];
+ boolean[] allowNestingInOutputLocations = new boolean[length+1];
+ outputLocations[0] = projectOutputLocation;
+
+ // retrieve and check output locations
+ IPath potentialNestedOutput = null; // for error reporting purpose
+ int sourceEntryCount = 0;
+ boolean disableExclusionPatterns = JavaCore.DISABLED.equals(javaProject.getOption(JavaCore.CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS, true));
+ boolean disableCustomOutputLocations = JavaCore.DISABLED.equals(javaProject.getOption(JavaCore.CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS, true));
+
+ for (int i = 0 ; i < length; i++) {
+ IClasspathEntry resolvedEntry = classpath[i];
+ switch(resolvedEntry.getEntryKind()){
+ case IClasspathEntry.CPE_SOURCE :
+ sourceEntryCount++;
+
+ if (disableExclusionPatterns &&
+ ((resolvedEntry.getInclusionPatterns() != null && resolvedEntry.getInclusionPatterns().length > 0)
+ || (resolvedEntry.getExclusionPatterns() != null && resolvedEntry.getExclusionPatterns().length > 0))) {
+ return new JavaModelStatus(IJavaModelStatusConstants.DISABLED_CP_EXCLUSION_PATTERNS, javaProject, resolvedEntry.getPath());
+ }
+ IPath customOutput;
+ if ((customOutput = resolvedEntry.getOutputLocation()) != null) {
+
+ if (disableCustomOutputLocations) {
+ return new JavaModelStatus(IJavaModelStatusConstants.DISABLED_CP_MULTIPLE_OUTPUT_LOCATIONS, javaProject, resolvedEntry.getPath());
+ }
+ // ensure custom output is in project
+ if (customOutput.isAbsolute()) {
+ if (!javaProject.getPath().isPrefixOf(customOutput)) {
+ return new JavaModelStatus(IJavaModelStatusConstants.PATH_OUTSIDE_PROJECT, javaProject, customOutput.toString());
+ }
+ } else {
+ return new JavaModelStatus(IJavaModelStatusConstants.RELATIVE_PATH, customOutput);
+ }
+
+ // ensure custom output doesn't conflict with other outputs
+ // check exact match
+ if (Util.indexOfMatchingPath(customOutput, outputLocations, outputCount) != -1) {
+ continue; // already found
+ }
+ // accumulate all outputs, will check nesting once all available (to handle ordering issues)
+ outputLocations[outputCount++] = customOutput;
+ }
+ }
+ }
+ // check nesting across output locations
+ for (int i = 1 /*no check for default output*/ ; i < outputCount; i++) {
+ IPath customOutput = outputLocations[i];
+ int index;
+ // check nesting
+ if ((index = Util.indexOfEnclosingPath(customOutput, outputLocations, outputCount)) != -1 && index != i) {
+ if (index == 0) {
+ // custom output is nested in project's output: need to check if all source entries have a custom
+ // output before complaining
+ if (potentialNestedOutput == null) potentialNestedOutput = customOutput;
+ } else {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.cannotNestOutputInOutput", customOutput.makeRelative().toString(), outputLocations[index].makeRelative().toString())); //$NON-NLS-1$
+ }
+ }
+ }
+ // allow custom output nesting in project's output if all source entries have a custom output
+ if (sourceEntryCount <= outputCount-1) {
+ allowNestingInOutputLocations[0] = true;
+ } else if (potentialNestedOutput != null) {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.cannotNestOutputInOutput", potentialNestedOutput.makeRelative().toString(), outputLocations[0].makeRelative().toString())); //$NON-NLS-1$
+ }
+
+ for (int i = 0 ; i < length; i++) {
+ IClasspathEntry resolvedEntry = classpath[i];
+ IPath path = resolvedEntry.getPath();
+ int index;
+ switch(resolvedEntry.getEntryKind()){
+
+ case IClasspathEntry.CPE_SOURCE :
+ hasSource = true;
+ if ((index = Util.indexOfMatchingPath(path, outputLocations, outputCount)) != -1){
+ allowNestingInOutputLocations[index] = true;
+ }
+ break;
+
+// case IClasspathEntry.CPE_LIBRARY:
+// hasLibFolder |= !org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(path.lastSegment());
+// if ((index = Util.indexOfMatchingPath(path, outputLocations, outputCount)) != -1){
+// allowNestingInOutputLocations[index] = true;
+// }
+// break;
+ }
+ }
+ if (!hasSource && !hasLibFolder) { // if no source and no lib folder, then allowed
+ for (int i = 0; i < outputCount; i++) allowNestingInOutputLocations[i] = true;
+ }
+
+ HashSet pathes = new HashSet(length);
+
+ // check all entries
+ for (int i = 0 ; i < length; i++) {
+ IClasspathEntry entry = classpath[i];
+ if (entry == null) continue;
+ IPath entryPath = entry.getPath();
+ int kind = entry.getEntryKind();
+
+ // Build some common strings for status message
+ boolean isProjectRelative = entryPath.segment(0).toString().equals(projectName);
+ String entryPathMsg = isProjectRelative ? entryPath.removeFirstSegments(1).toString() : entryPath.makeRelative().toString();
+
+ // complain if duplicate path
+ if (!pathes.add(entryPath)){
+ return new JavaModelStatus(IJavaModelStatusConstants.NAME_COLLISION, Util.bind("classpath.duplicateEntryPath", entryPathMsg, projectName)); //$NON-NLS-1$
+ }
+ // no further check if entry coincidates with project or output location
+ if (entryPath.equals(projectPath)){
+ // complain if self-referring project entry
+ if (kind == IClasspathEntry.CPE_PROJECT){
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_PATH, Util.bind("classpath.cannotReferToItself", entryPath.makeRelative().toString()));//$NON-NLS-1$
+ }
+ // tolerate nesting output in src if src==prj
+ continue;
+ }
+
+ // allow nesting source entries in each other as long as the outer entry excludes the inner one
+ if (kind == IClasspathEntry.CPE_SOURCE ) {
+// || (kind == IClasspathEntry.CPE_LIBRARY && !org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(entryPath.lastSegment()))){
+ for (int j = 0; j < classpath.length; j++){
+ IClasspathEntry otherEntry = classpath[j];
+ if (otherEntry == null) continue;
+ int otherKind = otherEntry.getEntryKind();
+ IPath otherPath = otherEntry.getPath();
+ if (entry != otherEntry
+ && (otherKind == IClasspathEntry.CPE_SOURCE ) ) {
+// || (otherKind == IClasspathEntry.CPE_LIBRARY
+// && !org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(otherPath.lastSegment())))){
+ char[][] inclusionPatterns, exclusionPatterns;
+ if (otherPath.isPrefixOf(entryPath)
+ && !otherPath.equals(entryPath)
+ && !Util.isExcluded(entryPath.append("*"), inclusionPatterns = ((ClasspathEntry)otherEntry).fullInclusionPatternChars(), exclusionPatterns = ((ClasspathEntry)otherEntry).fullExclusionPatternChars(), false)) { //$NON-NLS-1$
+ String exclusionPattern = entryPath.removeFirstSegments(otherPath.segmentCount()).segment(0);
+ if (Util.isExcluded(entryPath, inclusionPatterns, exclusionPatterns, false)) {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.mustEndWithSlash", exclusionPattern, entryPath.makeRelative().toString())); //$NON-NLS-1$
+ } else {
+ if (otherKind == IClasspathEntry.CPE_SOURCE) {
+ exclusionPattern += '/';
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.cannotNestEntryInEntry", new String[] {entryPath.makeRelative().toString(), otherEntry.getPath().makeRelative().toString(), exclusionPattern})); //$NON-NLS-1$
+ } else {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.cannotNestEntryInLibrary", entryPath.makeRelative().toString(), otherEntry.getPath().makeRelative().toString())); //$NON-NLS-1$
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // prevent nesting output location inside entry unless enclosing is a source entry which explicitly exclude the output location
+ char[][] inclusionPatterns = ((ClasspathEntry)entry).fullInclusionPatternChars();
+ char[][] exclusionPatterns = ((ClasspathEntry)entry).fullExclusionPatternChars();
+ for (int j = 0; j < outputCount; j++){
+ IPath currentOutput = outputLocations[j];
+ if (entryPath.equals(currentOutput)) continue;
+ if (entryPath.isPrefixOf(currentOutput)) {
+ if (kind != IClasspathEntry.CPE_SOURCE || !Util.isExcluded(currentOutput, inclusionPatterns, exclusionPatterns, true)) {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.cannotNestOutputInEntry", currentOutput.makeRelative().toString(), entryPath.makeRelative().toString())); //$NON-NLS-1$
+ }
+ }
+ }
+
+ // prevent nesting entry inside output location - when distinct from project or a source folder
+ for (int j = 0; j < outputCount; j++){
+ if (allowNestingInOutputLocations[j]) continue;
+ IPath currentOutput = outputLocations[j];
+ if (currentOutput.isPrefixOf(entryPath)) {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.cannotNestEntryInOutput", entryPath.makeRelative().toString(), currentOutput.makeRelative().toString())); //$NON-NLS-1$
+ }
+ }
+ }
+ // ensure that no specific output is coincidating with another source folder (only allowed if matching current source folder)
+ // 36465 - for 2.0 backward compatibility, only check specific output locations (the default can still coincidate)
+ // perform one separate iteration so as to not take precedence over previously checked scenarii (in particular should
+ // diagnose nesting source folder issue before this one, for example, [src]"Project/", [src]"Project/source/" and output="Project/" should
+ // first complain about missing exclusion pattern
+ for (int i = 0 ; i < length; i++) {
+ IClasspathEntry entry = classpath[i];
+ if (entry == null) continue;
+ IPath entryPath = entry.getPath();
+ int kind = entry.getEntryKind();
+
+ // Build some common strings for status message
+ boolean isProjectRelative = entryPath.segment(0).toString().equals(projectName);
+ String entryPathMsg = isProjectRelative ? entryPath.removeFirstSegments(1).toString() : entryPath.makeRelative().toString();
+
+ if (kind == IClasspathEntry.CPE_SOURCE) {
+ IPath output = entry.getOutputLocation();
+ if (output == null) continue; // 36465 - for 2.0 backward compatibility, only check specific output locations (the default can still coincidate)
+ // if (output == null) output = projectOutputLocation; // if no specific output, still need to check using default output (this line would check default output)
+ for (int j = 0; j < length; j++) {
+ IClasspathEntry otherEntry = classpath[j];
+ if (otherEntry == entry) continue;
+
+ // Build some common strings for status message
+ boolean opStartsWithProject = otherEntry.getPath().segment(0).toString().equals(projectName);
+ String otherPathMsg = opStartsWithProject ? otherEntry.getPath().removeFirstSegments(1).toString() : otherEntry.getPath().makeRelative().toString();
+
+ switch (otherEntry.getEntryKind()) {
+ case IClasspathEntry.CPE_SOURCE :
+ if (otherEntry.getPath().equals(output)) {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.cannotUseDistinctSourceFolderAsOutput", new String[] {entryPathMsg, otherPathMsg, projectName})); //$NON-NLS-1$
+ }
+ break;
+ case IClasspathEntry.CPE_LIBRARY :
+ if (otherEntry.getPath().equals(output)) {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.cannotUseLibraryAsOutput", new String[] {entryPathMsg, otherPathMsg, projectName})); //$NON-NLS-1$
+ }
+ }
+ }
+ }
+ }
+ return JavaModelStatus.VERIFIED_OK;
+ }
+
+ /**
+ * Returns a Java model status describing the problem related to this classpath entry if any,
+ * a status object with code IStatus.OK if the entry is fine (that is, if the
+ * given classpath entry denotes a valid element to be referenced onto a classpath).
+ *
+ * @param project the given java project
+ * @param entry the given classpath entry
+ * @param checkSourceAttachment a flag to determine if source attachement should be checked
+ * @param recurseInContainers flag indicating whether validation should be applied to container entries recursively
+ * @return a java model status describing the problem related to this classpath entry if any, a status object with code IStatus.OK if the entry is fine
+ */
+ public static IJavaModelStatus validateClasspathEntry(IJavaProject project, IClasspathEntry entry, boolean checkSourceAttachment, boolean recurseInContainers){
+
+ IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
+ IPath path = entry.getPath();
+
+ // Build some common strings for status message
+ String projectName = project.getElementName();
+ boolean pathStartsWithProject = path.segment(0).toString().equals(projectName);
+ String entryPathMsg = pathStartsWithProject ? path.removeFirstSegments(1).toString() : path.makeRelative().toString();
+
+ switch(entry.getEntryKind()){
+
+ // container entry check
+// case IClasspathEntry.CPE_CONTAINER :
+// if (path != null && path.segmentCount() >= 1){
+// try {
+// IClasspathContainer container = JavaModelManager.getJavaModelManager().getClasspathContainer(path, project);
+// // container retrieval is performing validation check on container entry kinds.
+// if (container == null){
+// return new JavaModelStatus(IJavaModelStatusConstants.CP_CONTAINER_PATH_UNBOUND, project, path);
+// } else if (container == JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS) {
+// // don't create a marker if initialization is in progress (case of cp initialization batching)
+// return JavaModelStatus.VERIFIED_OK;
+// }
+// IClasspathEntry[] containerEntries = container.getClasspathEntries();
+// if (containerEntries != null){
+// for (int i = 0, length = containerEntries.length; i < length; i++){
+// IClasspathEntry containerEntry = containerEntries[i];
+// int kind = containerEntry == null ? 0 : containerEntry.getEntryKind();
+// if (containerEntry == null
+// || kind == IClasspathEntry.CPE_SOURCE
+// || kind == IClasspathEntry.CPE_VARIABLE
+// || kind == IClasspathEntry.CPE_CONTAINER){
+// String description = container.getDescription();
+// if (description == null) description = path.makeRelative().toString();
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CP_CONTAINER_ENTRY, project, path);
+// }
+// if (recurseInContainers) {
+// IJavaModelStatus containerEntryStatus = validateClasspathEntry(project, containerEntry, checkSourceAttachment, recurseInContainers);
+// if (!containerEntryStatus.isOK()){
+// return containerEntryStatus;
+// }
+// }
+// }
+// }
+// } catch(JavaModelException e){
+// return new JavaModelStatus(e);
+// }
+// } else {
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.illegalContainerPath", entryPathMsg, projectName)); //$NON-NLS-1$
+// }
+// break;
+
+ // variable entry check
+ case IClasspathEntry.CPE_VARIABLE :
+ if (path != null && path.segmentCount() >= 1){
+ try {
+ entry = JavaCore.getResolvedClasspathEntry(entry);
+ } catch (Assert.AssertionFailedException e) {
+ // Catch the assertion failure and throw java model exception instead
+ // see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=55992
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_PATH, e.getMessage());
+ }
+ if (entry == null){
+ return new JavaModelStatus(IJavaModelStatusConstants.CP_VARIABLE_PATH_UNBOUND, project, path);
+ }
+ return validateClasspathEntry(project, entry, checkSourceAttachment, recurseInContainers);
+ } else {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.illegalVariablePath", path.makeRelative().toString(), projectName)); //$NON-NLS-1$
+ }
+
+ // library entry check
+// case IClasspathEntry.CPE_LIBRARY :
+// if (path != null && path.isAbsolute() && !path.isEmpty()) {
+// IPath sourceAttachment = entry.getSourceAttachmentPath();
+// Object target = JavaModel.getTarget(workspaceRoot, path, true);
+// if (target != null && project.getOption(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, true) != JavaCore.IGNORE) {
+// long projectTargetJDK = CompilerOptions.versionToJdkLevel(project.getOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, true));
+// long libraryJDK = Util.getJdkLevel(target);
+// if (libraryJDK != 0 && libraryJDK > projectTargetJDK) {
+// return new JavaModelStatus(IJavaModelStatusConstants.INCOMPATIBLE_JDK_LEVEL, project, path, CompilerOptions.versionFromJdkLevel(libraryJDK));
+// }
+// }
+// if (target instanceof IResource){
+// IResource resolvedResource = (IResource) target;
+// switch(resolvedResource.getType()){
+// case IResource.FILE :
+// if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(resolvedResource.getName())) {
+// if (checkSourceAttachment
+// && sourceAttachment != null
+// && !sourceAttachment.isEmpty()
+// && JavaModel.getTarget(workspaceRoot, sourceAttachment, true) == null){
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.unboundSourceAttachment", new String [] {sourceAttachment.makeRelative().toString(), path.makeRelative().toString(), projectName})); //$NON-NLS-1$
+// }
+// } else {
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.illegalLibraryArchive", entryPathMsg, projectName)); //$NON-NLS-1$
+// }
+// break;
+// case IResource.FOLDER : // internal binary folder
+// if (checkSourceAttachment
+// && sourceAttachment != null
+// && !sourceAttachment.isEmpty()
+// && JavaModel.getTarget(workspaceRoot, sourceAttachment, true) == null){
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.unboundSourceAttachment", new String [] {sourceAttachment.makeRelative().toString(), path.makeRelative().toString(), projectName})); //$NON-NLS-1$
+// }
+// }
+// } else if (target instanceof File){
+// File file = (File) target;
+// if (!file.isFile()) {
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.illegalExternalFolder", path.toOSString(), projectName)); //$NON-NLS-1$
+// } else if (!org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())) {
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.illegalLibraryArchive", path.toOSString(), projectName)); //$NON-NLS-1$
+// } else if (checkSourceAttachment
+// && sourceAttachment != null
+// && !sourceAttachment.isEmpty()
+// && JavaModel.getTarget(workspaceRoot, sourceAttachment, true) == null){
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.unboundSourceAttachment", new String [] {sourceAttachment.toString(), path.makeRelative().toString(), projectName})); //$NON-NLS-1$
+// }
+// } else {
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.unboundLibrary", path.makeRelative().toString(), projectName)); //$NON-NLS-1$
+// }
+// } else {
+// return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.illegalLibraryPath", path.makeRelative().toString(), projectName)); //$NON-NLS-1$
+// }
+// break;
+
+ // project entry check
+ case IClasspathEntry.CPE_PROJECT :
+ if (path != null && path.isAbsolute() && !path.isEmpty()) {
+ IProject prereqProjectRsc = workspaceRoot.getProject(path.segment(0));
+ IJavaProject prereqProject = JavaCore.create(prereqProjectRsc);
+ try {
+ if (!prereqProjectRsc.exists() || !prereqProjectRsc.hasNature(PHPeclipsePlugin.PHP_NATURE_ID)){
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.unboundProject", path.makeRelative().segment(0).toString(), projectName)); //$NON-NLS-1$
+ }
+ if (!prereqProjectRsc.isOpen()){
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.closedProject", path.segment(0).toString())); //$NON-NLS-1$
+ }
+// if (project.getOption(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, true) != JavaCore.IGNORE) {
+// long projectTargetJDK = CompilerOptions.versionToJdkLevel(project.getOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, true));
+// long prereqProjectTargetJDK = CompilerOptions.versionToJdkLevel(prereqProject.getOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, true));
+// if (prereqProjectTargetJDK > projectTargetJDK) {
+// return new JavaModelStatus(IJavaModelStatusConstants.INCOMPATIBLE_JDK_LEVEL, project, path, CompilerOptions.versionFromJdkLevel(prereqProjectTargetJDK));
+// }
+// }
+ } catch (CoreException e){
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.unboundProject", path.segment(0).toString(), projectName)); //$NON-NLS-1$
+ }
+ } else {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.illegalProjectPath", path.segment(0).toString(), projectName)); //$NON-NLS-1$
+ }
+ break;
+
+ // project source folder
+ case IClasspathEntry.CPE_SOURCE :
+ if (((entry.getInclusionPatterns() != null && entry.getInclusionPatterns().length > 0)
+ || (entry.getExclusionPatterns() != null && entry.getExclusionPatterns().length > 0))
+ && JavaCore.DISABLED.equals(project.getOption(JavaCore.CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS, true))) {
+ return new JavaModelStatus(IJavaModelStatusConstants.DISABLED_CP_EXCLUSION_PATTERNS, project, path);
+ }
+ if (entry.getOutputLocation() != null && JavaCore.DISABLED.equals(project.getOption(JavaCore.CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS, true))) {
+ return new JavaModelStatus(IJavaModelStatusConstants.DISABLED_CP_MULTIPLE_OUTPUT_LOCATIONS, project, path);
+ }
+ if (path != null && path.isAbsolute() && !path.isEmpty()) {
+ IPath projectPath= project.getProject().getFullPath();
+ if (!projectPath.isPrefixOf(path) || JavaModel.getTarget(workspaceRoot, path, true) == null){
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.unboundSourceFolder", entryPathMsg, projectName)); //$NON-NLS-1$
+ }
+ } else {
+ return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Util.bind("classpath.illegalSourceFolderPath", entryPathMsg, projectName)); //$NON-NLS-1$
+ }
+ break;
+ }
+ return JavaModelStatus.VERIFIED_OK;
}
}
+