/*******************************************************************************
* Copyright (c) 2000, 2016 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
*******************************************************************************/
package org.eclipse.dltk.internal.launching;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IBuildpathAttribute;
import org.eclipse.dltk.core.IBuildpathEntry;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.environment.EnvironmentManager;
import org.eclipse.dltk.core.environment.EnvironmentPathUtils;
import org.eclipse.dltk.core.environment.IEnvironment;
import org.eclipse.dltk.core.environment.IFileHandle;
import org.eclipse.dltk.launching.AbstractScriptLaunchConfigurationDelegate;
import org.eclipse.dltk.launching.IInterpreterInstall;
import org.eclipse.dltk.launching.IRuntimeBuildpathEntry;
import org.eclipse.dltk.launching.IRuntimeBuildpathEntryResolver;
import org.eclipse.dltk.launching.IRuntimeBuildpathEntryResolver2;
import org.eclipse.dltk.launching.LibraryLocation;
import org.eclipse.dltk.launching.ScriptLaunchConfigurationConstants;
import org.eclipse.dltk.launching.ScriptRuntime;
/**
* Resolves INTERPRETER_CONTAINER
*/
public class InterpreterRuntimeBuildpathEntryResolver
implements IRuntimeBuildpathEntryResolver2 {
/**
* @see IRuntimeBuildpathEntryResolver#resolveRuntimeBuildpathEntry(IRuntimeBuildpathEntry,
* ILaunchConfiguration)
*/
@Override
public IRuntimeBuildpathEntry[] resolveRuntimeBuildpathEntry(
IRuntimeBuildpathEntry entry, ILaunchConfiguration configuration)
throws CoreException {
String nature = configuration.getAttribute(
ScriptLaunchConfigurationConstants.ATTR_SCRIPT_NATURE,
(String) null);
IScriptProject project = AbstractScriptLaunchConfigurationDelegate
.getScriptProject(configuration);
IEnvironment environment = EnvironmentManager.getEnvironment(project);
IInterpreterInstall interpreterEnvironment = null;
if (entry.getType() == IRuntimeBuildpathEntry.CONTAINER
&& entry.getPath().segmentCount() > 1) {
// a specific Interpreter
interpreterEnvironment = InterpreterContainerInitializer
.resolveInterpreter(nature, environment.getId(),
entry.getPath());
} else {
// default Interpreter for config
interpreterEnvironment = ScriptRuntime
.computeInterpreterInstall(configuration);
}
if (interpreterEnvironment == null) {
// cannot resolve InterpreterEnvironment
return new IRuntimeBuildpathEntry[0];
}
return resolveLibraryLocations(interpreterEnvironment,
entry.getBuildpathProperty());
}
private String getNatureFromProject(IScriptProject project) {
return DLTKLanguageManager.getLanguageToolkit(project).getNatureId();
}
private String getEnvironmentFromProject(IScriptProject project) {
return EnvironmentManager.getEnvironment(project).getId();
}
/**
* @see IRuntimeBuildpathEntryResolver#resolveRuntimeBuildpathEntry(IRuntimeBuildpathEntry,
* IScriptProject)
*/
@Override
public IRuntimeBuildpathEntry[] resolveRuntimeBuildpathEntry(
IRuntimeBuildpathEntry entry, IScriptProject project)
throws CoreException {
IInterpreterInstall interpreterEnvironment = null;
if (entry.getType() == IRuntimeBuildpathEntry.CONTAINER
&& entry.getPath().segmentCount() > 1) {
// a specific Interpreter
interpreterEnvironment = InterpreterContainerInitializer
.resolveInterpreter(getNatureFromProject(project),
getEnvironmentFromProject(project),
entry.getPath());
} else {
// default Interpreter for project
interpreterEnvironment = ScriptRuntime
.getInterpreterInstall(project);
}
if (interpreterEnvironment == null) {
// cannot resolve InterpreterEnvironment
return new IRuntimeBuildpathEntry[0];
}
return resolveLibraryLocations(interpreterEnvironment,
entry.getBuildpathProperty());
}
/**
* Resolves library locations for the given Interpreter install
*/
protected IRuntimeBuildpathEntry[] resolveLibraryLocations(
IInterpreterInstall interpreter, int kind) {
LibraryLocation[] libs = interpreter.getLibraryLocations();
LibraryLocation[] defaultLibs = interpreter.getInterpreterInstallType()
.getDefaultLibraryLocations(interpreter.getInstallLocation(),
interpreter.getEnvironmentVariables(), null);
if (libs == null) {
// default system libs
libs = defaultLibs;
} else if (!isSamePaths(libs, defaultLibs)) {
// determine if bootpath should be explicit
kind = IRuntimeBuildpathEntry.BOOTSTRAP_ENTRY;
}
List<IRuntimeBuildpathEntry> resolvedEntries = new ArrayList<>(
libs.length);
final IEnvironment environment = interpreter.getEnvironment();
for (int i = 0; i < libs.length; i++) {
IPath systemLibraryPath = libs[i].getLibraryPath();
if (!contains(defaultLibs, systemLibraryPath)) {
final boolean exists;
if (environment != null) {
final IFileHandle fileHandle = EnvironmentPathUtils
.getFile(environment, systemLibraryPath);
if (fileHandle != null) {
exists = fileHandle.exists();
} else {
exists = true;
}
} else {
exists = systemLibraryPath.toFile().exists();
}
if (exists) {
resolvedEntries.add(
resolveLibraryLocation(interpreter, libs[i], kind));
}
}
}
return resolvedEntries
.toArray(new IRuntimeBuildpathEntry[resolvedEntries.size()]);
}
/**
* @param libs
* @param path
* @return
*/
private static boolean contains(LibraryLocation[] libs, IPath path) {
final IPathEquality compare = PathEqualityUtils.getInstance();
for (int i = 0; i < libs.length; ++i) {
if (compare.equals(path, libs[i].getLibraryPath())) {
return true;
}
}
return false;
}
public static boolean isSamePaths(LibraryLocation[] libs,
LibraryLocation[] defaultLibs) {
final int length = defaultLibs.length;
if (libs.length != length) {
return false;
}
if (length != 0) {
// TODO paths could be remote...
final IPathEquality compare = PathEqualityUtils.getInstance();
for (int i = 0; i < length; i++) {
IPath dpath = defaultLibs[i].getLibraryPath();
IPath lpath = libs[i].getLibraryPath();
if (!compare.equals(dpath, lpath)) {
return false;
}
}
}
return true;
}
/**
* Return whether the given list of libraries refer to the same archives in
* the same order. Only considers the binary archive (not source or javadoc
* locations).
*
* @param libs
* @param defaultLibs
* @return whether the given list of libraries refer to the same archives in
* the same order
*/
public static boolean isSameArchives(LibraryLocation[] libs,
LibraryLocation[] defaultLibs) {
if (libs.length != defaultLibs.length) {
return false;
}
for (int i = 0; i < defaultLibs.length; i++) {
LibraryLocation def = defaultLibs[i];
LibraryLocation lib = libs[i];
if (!def.getLibraryPath().equals(lib.getLibraryPath())) {
return false;
}
}
return true;
}
/**
* @see IRuntimeBuildpathEntryResolver#resolveInterpreterInstall(IBuildpathEntry)
*/
@Override
public IInterpreterInstall resolveInterpreterInstall(String lang,
String environment, IBuildpathEntry entry) {
if (entry.getEntryKind() == IBuildpathEntry.BPE_CONTAINER)
if (entry.getPath().segment(0)
.equals(ScriptRuntime.INTERPRETER_CONTAINER)) {
try {
return InterpreterContainerInitializer.resolveInterpreter(
lang, environment, entry.getPath());
} catch (CoreException e) {
return null;
}
}
return null;
}
@Override
public boolean isInterpreterInstallReference(String lang,
String environment, IBuildpathEntry entry) {
if (entry.getEntryKind() == IBuildpathEntry.BPE_CONTAINER)
if (entry.getPath().segment(0)
.equals(ScriptRuntime.INTERPRETER_CONTAINER)) {
return true;
}
return false;
}
/**
* Returns a runtime buildpath entry for the given library in the specified
* Interpreter.
*
* @param Interpreter
* @param location
* @param kind
* @return runtime buildpath entry
*
*/
private IRuntimeBuildpathEntry resolveLibraryLocation(
IInterpreterInstall Interpreter, LibraryLocation location,
int kind) {
IPath libraryPath = location.getLibraryPath();
IBuildpathAttribute[] attributes = new IBuildpathAttribute[0];
IBuildpathEntry bpe = DLTKCore.newLibraryEntry(libraryPath,
IBuildpathEntry.NO_ACCESS_RULES, attributes, false, false);
IRuntimeBuildpathEntry resolved = new RuntimeBuildpathEntry(bpe);
resolved.setBuildpathProperty(kind);
return resolved;
}
}