diff --git a/debug/org.eclipse.cdt.debug.core/plugin.xml b/debug/org.eclipse.cdt.debug.core/plugin.xml index 4c89ce0cc3c..f29545570b0 100644 --- a/debug/org.eclipse.cdt.debug.core/plugin.xml +++ b/debug/org.eclipse.cdt.debug.core/plugin.xml @@ -6,6 +6,10 @@ + + + + diff --git a/debug/org.eclipse.cdt.debug.core/schema/ExecutablesImporter.exsd b/debug/org.eclipse.cdt.debug.core/schema/ExecutablesImporter.exsd new file mode 100644 index 00000000000..a779f20d88d --- /dev/null +++ b/debug/org.eclipse.cdt.debug.core/schema/ExecutablesImporter.exsd @@ -0,0 +1,86 @@ + + + + + + + + + This extension points allows you to extened the executables manager in CDT by providing your own executables importer. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CDT 7.0 + + + + + + + + + <extension + point="org.eclipse.cdt.debug.core.ExecutablesImporter"> + <modifier class="com.xyz.MyExecutablesImporter"/> + </extension> + + + + diff --git a/debug/org.eclipse.cdt.debug.core/schema/ExecutablesProvider.exsd b/debug/org.eclipse.cdt.debug.core/schema/ExecutablesProvider.exsd new file mode 100644 index 00000000000..f0769b52a11 --- /dev/null +++ b/debug/org.eclipse.cdt.debug.core/schema/ExecutablesProvider.exsd @@ -0,0 +1,86 @@ + + + + + + + + + This extension points allows you to extened the executables manager in CDT by providing your own executables provider for certain types of projects. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CDT 7.0 + + + + + + + + + <extension + point="org.eclipse.cdt.debug.core.ExecutablesProvider"> + <modifier class="com.xyz.MyExecutablesProvider"/> + </extension> + + + + diff --git a/debug/org.eclipse.cdt.debug.core/schema/SourceFilesProvider.exsd b/debug/org.eclipse.cdt.debug.core/schema/SourceFilesProvider.exsd new file mode 100644 index 00000000000..59d43a47af9 --- /dev/null +++ b/debug/org.eclipse.cdt.debug.core/schema/SourceFilesProvider.exsd @@ -0,0 +1,86 @@ + + + + + + + + + This extension points allows you to extened the executables manager in CDT by providing your own source files provider for certain types of executables. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CDT 7.0 + + + + + + + + + <extension + point="org.eclipse.cdt.debug.core.SourceFilesProvider"> + <modifier class="com.xyz.MySourceFilesProvider"/> + </extension> + + + + diff --git a/debug/org.eclipse.cdt.debug.core/schema/SourceRemappingProvider.exsd b/debug/org.eclipse.cdt.debug.core/schema/SourceRemappingProvider.exsd new file mode 100644 index 00000000000..97d9101e7cb --- /dev/null +++ b/debug/org.eclipse.cdt.debug.core/schema/SourceRemappingProvider.exsd @@ -0,0 +1,86 @@ + + + + + + + + + This extension points allows you to extened the executables manager in CDT by providing your own source remapping provider. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CDT 7.0 + + + + + + + + + <extension + point="org.eclipse.cdt.debug.core.SourceRemappingProvider"> + <modifier class="com.xyz.MySourceRemappingProvider"/> + </extension> + + + + diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/Executable.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/Executable.java index d7f25480b59..7242eda6f18 100644 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/Executable.java +++ b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/Executable.java @@ -136,7 +136,7 @@ public class Executable extends PlatformObject { * @noreference This method is not intended to be referenced by clients. * @since 6.0 */ - public ITranslationUnit[] getSourceFiles(IProgressMonitor monitor) { + public synchronized ITranslationUnit[] getSourceFiles(IProgressMonitor monitor) { if (!refreshSourceFiles) return sourceFiles.toArray(new TranslationUnit[sourceFiles.size()]) ; @@ -166,6 +166,7 @@ public class Executable extends PlatformObject { // breakpoints won't be resolved, etc.. Also check for relative // path names and attempt to resolve them relative to the // executable. + boolean fileExists = false; try { @@ -214,8 +215,7 @@ public class Executable extends PlatformObject { // Be careful not to convert a unix path like // "/src/home" to "c:\source\home" on Windows. See // bugzilla 297781 - URI uri = (sourcePath.toFile().exists()) ? URIUtil.toURI(sourcePath) : URIUtil.toURI(filename); - + URI uri = (sourcePath.toFile().exists()) ? URIUtil.toURI(sourcePath) : URIUtil.toURI(filename); tu = new ExternalTranslationUnit(cproject, uri, id); } @@ -239,7 +239,7 @@ public class Executable extends PlatformObject { this.refreshSourceFiles = refreshSourceFiles; } - public String getOriginalLocation(ITranslationUnit tu) { + public synchronized String getOriginalLocation(ITranslationUnit tu) { String orgLocation = remappedPaths.get(tu); if (orgLocation == null) orgLocation = tu.getLocation().toOSString(); diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/ExecutablesManager.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/ExecutablesManager.java index 3268ab453e9..9f2e25da034 100644 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/ExecutablesManager.java +++ b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/ExecutablesManager.java @@ -11,29 +11,50 @@ package org.eclipse.cdt.debug.core.executables; +import java.text.DateFormat; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Comparator; +import java.util.Date; import java.util.HashMap; import java.util.List; +import java.util.Map; +import org.eclipse.cdt.core.model.CoreModel; +import org.eclipse.cdt.core.settings.model.CProjectDescriptionEvent; +import org.eclipse.cdt.core.settings.model.ICProjectDescription; +import org.eclipse.cdt.core.settings.model.ICProjectDescriptionListener; import org.eclipse.cdt.debug.core.CDebugCorePlugin; -import org.eclipse.cdt.debug.internal.core.executables.ExecutablesChangeEvent; import org.eclipse.cdt.debug.internal.core.executables.StandardExecutableImporter; -import org.eclipse.cdt.debug.internal.core.executables.StandardExecutableProvider; import org.eclipse.cdt.debug.internal.core.executables.StandardSourceFileRemapping; import org.eclipse.cdt.debug.internal.core.executables.StandardSourceFilesProvider; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IProjectDescription; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.resources.IResourceChangeEvent; +import org.eclipse.core.resources.IResourceChangeListener; +import org.eclipse.core.resources.IResourceDelta; +import org.eclipse.core.resources.IResourceDeltaVisitor; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.IExtension; +import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IExtensionRegistry; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.MultiStatus; +import org.eclipse.core.runtime.Platform; import org.eclipse.core.runtime.PlatformObject; import org.eclipse.core.runtime.Status; +import org.eclipse.core.runtime.SubMonitor; import org.eclipse.core.runtime.SubProgressMonitor; import org.eclipse.core.runtime.jobs.Job; -import org.eclipse.debug.core.DebugPlugin; +import org.eclipse.osgi.service.debug.DebugOptions; +import org.osgi.framework.BundleContext; +import org.osgi.framework.ServiceReference; /** * The Executables Manager maintains a collection of executables built by all of @@ -43,28 +64,70 @@ import org.eclipse.debug.core.DebugPlugin; * @author Ken Ryall * */ -public class ExecutablesManager extends PlatformObject { +public class ExecutablesManager extends PlatformObject implements IResourceChangeListener, ICProjectDescriptionListener { - private final HashMap executables = new HashMap(); - private final List changeListeners = Collections.synchronizedList(new ArrayList()); - private final List sourceFileRemappings = Collections.synchronizedList(new ArrayList()); - private final List executableProviders = Collections.synchronizedList(new ArrayList()); - private final List sourceFileProviders = Collections.synchronizedList(new ArrayList()); - private final List executableImporters = Collections.synchronizedList(new ArrayList()); - private boolean refreshNeeded = true; - private boolean tempDisableRefresh = false; + private static final String EXECUTABLES_MANAGER_DEBUG_TRACING = CDebugCorePlugin.PLUGIN_ID + "EXECUTABLES_MANAGER_DEBUG_TRACING"; //$NON-NLS-1$ - private final Job refreshJob = new Job("Get Executables") { + private Map executablesProviderMap = new HashMap(); + private Map> executablesMap = new HashMap>(); + private List changeListeners = Collections.synchronizedList(new ArrayList()); + private List executableProviders; + private List sourceFileProviders; + private List sourceFileRemappings; + private List executableImporters; + + private boolean DEBUG; + + private Job refreshJob = new Job("Get Executables") { //$NON-NLS-1$ @Override public IStatus run(IProgressMonitor monitor) { - refreshExecutables(monitor); + + trace("Get Executables job started at " + getStringFromTimestamp(System.currentTimeMillis())); //$NON-NLS-1$ + + List projects = getProjectsToCheck(); + + SubMonitor subMonitor = SubMonitor.convert(monitor, projects.size()); + + for (IProject project : projects) { + if (subMonitor.isCanceled()) { + trace("Get Executables job cancelled at " + getStringFromTimestamp(System.currentTimeMillis())); //$NON-NLS-1$ + return Status.CANCEL_STATUS; + } + + subMonitor.subTask("Checking project: " + project.getName()); //$NON-NLS-1$ + + // get the executables provider for this project + IProjectExecutablesProvider provider = getExecutablesProviderForProject(project); + if (provider != null) { + trace("Getting executables for project: " + project.getName() + " using " + provider.toString()); //$NON-NLS-1$//$NON-NLS-2$ + + // store the list of executables for this project + synchronized (executablesMap) { + executablesMap.put(project, provider.getExecutables(project, subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE))); + } + } + } + + // notify the listeners + synchronized (changeListeners) { + for (IExecutablesChangeListener listener : changeListeners) { + listener.executablesListChanged(); + } + } + + trace("Get Executables job finished at " + getStringFromTimestamp(System.currentTimeMillis())); //$NON-NLS-1$ + return Status.OK_STATUS; } }; private static ExecutablesManager executablesManager = null; + /** + * Get the executables manager instance + * @return the executables manager + */ public static ExecutablesManager getExecutablesManager() { if (executablesManager == null) executablesManager = new ExecutablesManager(); @@ -72,130 +135,150 @@ public class ExecutablesManager extends PlatformObject { } public ExecutablesManager() { - addSourceFileRemapping(new StandardSourceFileRemapping()); - addExecutableImporter(new StandardExecutableImporter()); - addExecutablesProvider(new StandardExecutableProvider()); - addSourceFilesProvider(new StandardSourceFilesProvider()); + + // check if debugging is enabled + BundleContext context = CDebugCorePlugin.getDefault().getBundle().getBundleContext(); + if (context != null) { + ServiceReference reference = CDebugCorePlugin.getDefault().getBundle().getBundleContext().getServiceReference(DebugOptions.class.getName()); + if (reference != null) { + DebugOptions service = (DebugOptions) context.getService(reference); + if (service != null) { + try { + DEBUG = service.getBooleanOption(EXECUTABLES_MANAGER_DEBUG_TRACING, false); + } finally { + // we have what we want - release the service + context.ungetService(reference); + } + } + } + } + + refreshJob.setPriority(Job.SHORT); + + // load the extension points + loadExecutableProviderExtensions(); + loadSoureFileProviderExtensions(); + loadSoureRemappingExtensions(); + loadExecutableImporterExtensions(); + + // add the standard providers + executableProviders.add(0, new StandardExecutableProvider()); + sourceFileProviders.add(0, new StandardSourceFilesProvider()); + sourceFileRemappings.add(0, new StandardSourceFileRemapping()); + executableImporters.add(0, new StandardExecutableImporter()); + + // listen for events we're interested in + ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE | IResourceChangeEvent.POST_BUILD); + CoreModel.getDefault().getProjectDescriptionManager().addCProjectDescriptionListener(this, + CProjectDescriptionEvent.APPLIED); + + // schedule a refresh so we get up to date + scheduleRefresh(); } + /** + * Adds an executable listener + * @param listener the listener to add + */ public void addExecutablesChangeListener(IExecutablesChangeListener listener) { changeListeners.add(listener); } + /** + * Removes an executable listener + * @param listener the listener to remove + */ public void removeExecutablesChangeListener(IExecutablesChangeListener listener) { changeListeners.remove(listener); } - public void addSourceFileRemapping(ISourceFileRemapping remapping) { - sourceFileRemappings.add(remapping); - } - - public void removeSourceFileRemapping(ISourceFileRemapping remapping) { - sourceFileRemappings.remove(remapping); - } - - public void addExecutableImporter(IExecutableImporter importer) { - executableImporters.add(importer); - } - - public void removeExecutableImporter(IExecutableImporter importer) { - executableImporters.remove(importer); - } - - public void addExecutablesProvider(IExecutableProvider provider) { - executableProviders.add(provider); - } - /** - * @since 6.0 + * Gets the list of executables in the workspace. + * @param wait whether or not to wait if the list is being refreshed when this + * method is called. when true, this call will not return until the list is + * complete. when false, it will return with the last known list. if calling + * from any UI, you should not block the UI waiting for this to return, but rather + * register as an {@link IExecutablesChangeListener} to get notifications when the + * list changes. + * @return the list of executables which may be empty + * @since 7.0 */ - public void addSourceFilesProvider(ISourceFilesProvider provider) { - sourceFileProviders.add(provider); - } - - /** - * @since 6.0 - */ - public void removeSourceFilesProvider(ISourceFilesProvider provider) { - sourceFileProviders.remove(provider); - } - - public void removeExecutablesProvider(IExecutableProvider provider) { - executableProviders.remove(provider); - } - - public IStatus refreshExecutables(IProgressMonitor monitor) { - if (tempDisableRefresh) { - return Status.OK_STATUS; - } - + public Collection getExecutables(boolean wait) { - synchronized (executables) { - HashMap oldList = new HashMap(executables); - executables.clear(); + trace("getExecutables called at " + getStringFromTimestamp(System.currentTimeMillis())); //$NON-NLS-1$ - IExecutableProvider[] exeProviders = getExecutableProviders(); + List executables = new ArrayList(); - Arrays.sort(exeProviders, new Comparator() { - - public int compare(IExecutableProvider arg0, IExecutableProvider arg1) { - int p0 = arg0.getPriority(); - int p1 = arg1.getPriority(); - if (p0 > p1) - return 1; - if (p0 < p1) - return -1; - return 0; - }}); - - refreshNeeded = false; - monitor.beginTask("Refresh Executables", exeProviders.length); - for (IExecutableProvider provider : exeProviders) { - Executable[] exes = provider.getExecutables(new SubProgressMonitor(monitor, 1)); - for (Executable executable : exes) { - executables.put(executable.getPath().toOSString(), executable); - } - } - monitor.done(); - - synchronized (changeListeners) { - Collection newExes = executables.values(); - Executable[] exeArray = newExes.toArray(new Executable[newExes.size()]); - Collection oldExes = oldList.values(); - Executable[] oldArray = oldExes.toArray(new Executable[oldExes.size()]); - for (IExecutablesChangeListener listener : changeListeners) { - listener.executablesChanged(new ExecutablesChangeEvent(oldArray, exeArray)); - } - } - } - - return monitor.isCanceled() ? Status.CANCEL_STATUS : Status.OK_STATUS; - } - - public Executable[] getExecutables() { - if (refreshNeeded) { + if (wait && refreshJob.getState() != Job.NONE) { + trace("waiting for refresh job to finish at " + getStringFromTimestamp(System.currentTimeMillis())); //$NON-NLS-1$ try { - refreshJob.schedule(); refreshJob.join(); } catch (InterruptedException e) { - DebugPlugin.log( e ); } + trace("refresh job finished at " + getStringFromTimestamp(System.currentTimeMillis())); //$NON-NLS-1$ } - synchronized (executables) - { - Collection exes = executables.values(); - return exes.toArray(new Executable[exes.size()]); + synchronized (executablesMap) { + for (List exes : executablesMap.values()) { + for (Executable exe : exes) { + if (!executables.contains(exe)) { + executables.add(exe); + } + } + } } + + trace("getExecutables returned at " + getStringFromTimestamp(System.currentTimeMillis())); //$NON-NLS-1$ + + return executables; } /** - * @since 6.0 + * Gets the list of executables in the workspace. Equivalent to {@link ExecutablesManager}{@link #getExecutables(false)}. + * Just kept for older API compatibility. + * @return the list of executables which may be empty + * @since 7.0 + */ + public Collection getExecutables() { + return getExecutables(false); + } + + /** + * @since 7.0 + * Gets the collection of executables for the given project + * @param project the project + * @return collection of executables which may be empty + */ + public Collection getExecutablesForProject(IProject project) { + List executables = new ArrayList(); + + synchronized (executablesMap) { + List exes = executablesMap.get(project); + if (exes != null) { + for (Executable exe : exes) { + if (!executables.contains(exe)) { + executables.add(exe); + } + } + } + } + + return executables; + } + + /** + * Attempt to remap the path to the given source file in the given executable using + * source file mapping extensions + * @param executable the executable + * @param filePath the absolute path to the source file + * @return the new path to the source file, which was remapped if possible + * + * @since 6.0 */ public String remapSourceFile(Executable executable, String filePath) { synchronized (sourceFileRemappings) { for (ISourceFileRemapping remapping : sourceFileRemappings) { - String remappedPath = remapping.remapSourceFile(executable, filePath); + String remappedPath = remapping.remapSourceFile(executable.getPath(), filePath); if (!remappedPath.equals(filePath)) return remappedPath; } @@ -203,82 +286,70 @@ public class ExecutablesManager extends PlatformObject { return filePath; } + /** + * Import the given executables into the manager + * @param fileNames the absolute paths of the executables to import + * @param monitor progress monitor + */ public void importExecutables(final String[] fileNames, IProgressMonitor monitor) { + boolean handled = false; - try { - - tempDisableRefresh = true; - monitor.beginTask("Import Executables", executableImporters.size()); - synchronized (executableImporters) { - Collections.sort(executableImporters, new Comparator() { + monitor.beginTask("Import Executables", executableImporters.size()); //$NON-NLS-1$ + synchronized (executableImporters) { + Collections.sort(executableImporters, new Comparator() { - public int compare(IExecutableImporter arg0, IExecutableImporter arg1) { - int p0 = arg0.getPriority(fileNames); - int p1 = arg1.getPriority(fileNames); - if (p0 < p1) - return 1; - if (p0 > p1) - return -1; - return 0; - }}); + public int compare(IExecutableImporter arg0, IExecutableImporter arg1) { + int p0 = arg0.getPriority(fileNames); + int p1 = arg1.getPriority(fileNames); + if (p0 < p1) + return 1; + if (p0 > p1) + return -1; + return 0; + }}); - for (IExecutableImporter importer : executableImporters) { - handled = importer.importExecutables(fileNames, new SubProgressMonitor(monitor, 1)); - if (handled || monitor.isCanceled()) { - break; - } + for (IExecutableImporter importer : executableImporters) { + handled = importer.importExecutables(fileNames, new SubProgressMonitor(monitor, 1)); + if (handled || monitor.isCanceled()) { + break; } } - - } finally { - tempDisableRefresh = false; } if (handled) - refreshExecutables(monitor); - monitor.done(); - } - - public ISourceFileRemapping[] getSourceFileRemappings() { - return sourceFileRemappings.toArray(new ISourceFileRemapping[sourceFileRemappings.size()]); - } - - public IExecutableProvider[] getExecutableProviders() { - return executableProviders.toArray(new IExecutableProvider[executableProviders.size()]); + scheduleRefresh(); } /** - * @since 6.0 + * Determines if the given executable is currently known by the manager + * @param exePath the absolute path to the executable + * @return true if the manager knows about it, false otherwise */ - public ISourceFilesProvider[] getSourceFileProviders() { - return sourceFileProviders.toArray(new ISourceFilesProvider[sourceFileProviders.size()]); - } - - public IExecutableImporter[] getExecutableImporters() { - return executableImporters.toArray(new IExecutableImporter[executableImporters.size()]); - } - - public void scheduleRefresh(IExecutableProvider provider, long delay) { - refreshNeeded = true; - refreshJob.schedule(delay); - } - - public boolean refreshNeeded() { - return refreshNeeded; - } - public boolean executableExists(IPath exePath) { - synchronized (executables) { - return executables.containsKey(exePath.toOSString()); + synchronized (executablesMap) { + for (List exes : executablesMap.values()) { + for (Executable exe : exes) { + if (exe.getPath().equals(exePath)) { + return true; + } + } + } } + + return false; } /** - * @since 6.0 + * Get the list of source files for the given executable + * @param executable the executable + * @param monitor progress monitor + * @return an array of source files which may be empty */ - public String[] getSourceFiles(final Executable executable, - IProgressMonitor monitor) { + public String[] getSourceFiles(final Executable executable, IProgressMonitor monitor) { String[] result = new String[0]; + + trace("getSourceFiles called at " + getStringFromTimestamp(System.currentTimeMillis()) + " for " + executable.getPath().toOSString()); //$NON-NLS-1$//$NON-NLS-2$ + synchronized (sourceFileProviders) { Collections.sort(sourceFileProviders, new Comparator() { @@ -292,70 +363,426 @@ public class ExecutablesManager extends PlatformObject { return 0; }}); - monitor.beginTask("Finding source files in " + executable.getName(), sourceFileProviders.size()); + monitor.beginTask("Finding source files in " + executable.getName(), sourceFileProviders.size()); //$NON-NLS-1$ for (ISourceFilesProvider provider : sourceFileProviders) { String[] sourceFiles = provider.getSourceFiles(executable, new SubProgressMonitor(monitor, 1)); - if (sourceFiles.length > 0) - { + if (sourceFiles.length > 0) { result = sourceFiles; + + trace("getSourceFiles got " + sourceFiles.length + " files from " + provider.toString()); //$NON-NLS-1$ //$NON-NLS-2$ + break; } } monitor.done(); } + + trace("getSourceFiles returned at " + getStringFromTimestamp(System.currentTimeMillis())); //$NON-NLS-1$ + return result; } /** + * Removes the given executables + * @param executables the array of executables to be removed + * @param monitor progress monitor + * @return IStatus of the operation + * * @since 6.0 */ public IStatus removeExecutables(Executable[] executables, IProgressMonitor monitor) { - IExecutableProvider[] exeProviders = getExecutableProviders(); - - IStatus result = Status.OK_STATUS; + MultiStatus status = new MultiStatus(CDebugCorePlugin.PLUGIN_ID, IStatus.WARNING, "Couldn't remove all of the selected executables", null); //$NON-NLS-1$ - Arrays.sort(exeProviders, new Comparator() { - - public int compare(IExecutableProvider arg0, IExecutableProvider arg1) { - int p0 = arg0.getPriority(); - int p1 = arg1.getPriority(); - if (p0 > p1) - return 1; - if (p0 < p1) - return -1; - return 0; - } - }); - - MultiStatus combinedStatus = new MultiStatus(CDebugCorePlugin.PLUGIN_ID, IStatus.WARNING, "Couldn't remove all of the selected executables", null); - refreshNeeded = false; - monitor.beginTask("Remove Executables", exeProviders.length); + monitor.beginTask("Remove Executables", executables.length); //$NON-NLS-1$ for (Executable executable : executables) { - boolean handled = false; - IStatus rmvStatus = Status.OK_STATUS;; - for (IExecutableProvider provider : exeProviders) { - if (!handled) - { - rmvStatus = provider.removeExecutable(executable, new SubProgressMonitor(monitor, 1)); - handled = rmvStatus.getSeverity() == IStatus.OK; - } - } - if (!handled) - { - combinedStatus.add(rmvStatus); - result = combinedStatus; + + IProjectExecutablesProvider provider = getExecutablesProviderForProject(executable.getProject()); + if (provider != null) { + IStatus result = provider.removeExecutable(executable, new SubProgressMonitor(monitor, 1)); + if (result.isOK()) { + // remove the exe from the list + List exes = executablesMap.get(executable.getProject()); + if (exes != null) { + exes.remove(executable); + } + } else { + status.add(result); + } + } + } + + // notify listeners that the list has changed. only do this if at least one delete succeeded. + if (status.getChildren().length != executables.length) { + synchronized (changeListeners) { + for (IExecutablesChangeListener listener : changeListeners) { + listener.executablesListChanged(); + } } } - monitor.done(); - return result; + return status; } /** - * @since 6.0 + * Refresh the list of executables for the given projects + * @param projects the list of projects, or null. if null or the list + * is empty, all projects will be refreshed. + * @since 7.0 */ - public void setRefreshNeeded(boolean refresh) { - refreshNeeded = true; + public void refresh(List projects) { + if (projects == null || projects.size() == 0) { + // clear the entire cache + executablesMap.clear(); + } else { + for (IProject project : projects) { + executablesMap.remove(project); + } + } + + scheduleRefresh(); } -} \ No newline at end of file + /** + * @since 7.0 + */ + public void resourceChanged(IResourceChangeEvent event) { + + synchronized (executablesMap) { + // project needs to be refreshed after a build/clean as the binary may + // be added/removed/renamed etc. + if (event.getType() == IResourceChangeEvent.POST_BUILD) { + Object obj = event.getSource(); + if (obj != null && obj instanceof IProject) { + try { + // make sure there's at least one builder for the project. this gets called even + // when there are no builder (e.g. the Executables project for imported executables). + IProject project = (IProject)obj; + if (project.getDescription().getBuildSpec().length > 0) { + if (executablesMap.containsKey(obj)) { + List executables = executablesMap.remove(obj); + + trace("Scheduling refresh because project " + ((IProject)obj).getName() + " built or cleaned"); //$NON-NLS-1$//$NON-NLS-2$ + + scheduleRefresh(); + + // notify the listeners that these executables have possibly changed + if (executables != null && executables.size() > 0) { + synchronized (changeListeners) { + for (IExecutablesChangeListener listener : changeListeners) { + listener.executablesChanged(executables); + } + } + } + } + } + } catch (CoreException e) { + e.printStackTrace(); + } + } + return; + } + + // refresh when projects are opened or closed. note that deleted + // projects are handled later in this method. new projects are handled + // in handleEvent. resource changed events always start at the workspace + // root, so projects are the next level down + boolean refreshNeeded = false; + IResourceDelta[] projects = event.getDelta().getAffectedChildren(); + for (IResourceDelta projectDelta : projects) { + if ((projectDelta.getFlags() & IResourceDelta.OPEN) != 0) { + if (projectDelta.getKind() == IResourceDelta.CHANGED) { + // project was opened or closed + if (executablesMap.containsKey(projectDelta.getResource())) { + executablesMap.remove(projectDelta.getResource()); + } + refreshNeeded = true; + } + } + } + + if (refreshNeeded) { + trace("Scheduling refresh because project(s) opened or closed"); //$NON-NLS-1$ + + scheduleRefresh(); + return; + } + + try { + event.getDelta().accept(new IResourceDeltaVisitor() { + + public boolean visit(IResourceDelta delta) throws CoreException { + if (delta.getKind() == IResourceDelta.ADDED || delta.getKind() == IResourceDelta.REMOVED) { + IResource deltaResource = delta.getResource(); + if (deltaResource != null) { + boolean refresh = false; + if (delta.getKind() == IResourceDelta.REMOVED && deltaResource instanceof IProject) { + // project deleted + if (executablesMap.containsKey(deltaResource)) { + executablesMap.remove(deltaResource); + refresh = true; + + trace("Scheduling refresh because project " + deltaResource.getName() + " deleted"); //$NON-NLS-1$//$NON-NLS-2$ + } + } else { + // see if a binary has been added/removed + IPath resourcePath = deltaResource.getLocation(); + if (resourcePath != null && Executable.isExecutableFile(resourcePath)) { + if (executablesMap.containsKey(deltaResource.getProject())) { + executablesMap.remove(deltaResource.getProject()); + refresh = true; + + trace("Scheduling refresh because a binary was added/removed"); //$NON-NLS-1$ + } + } + } + + if (refresh) { + scheduleRefresh(); + return false; + } + } + } + return true; + } + }); + } catch (CoreException e) { + } + } + } + + /** + * @since 7.0 + */ + public void handleEvent(CProjectDescriptionEvent event) { + // this handles the cases where the active build configuration changes, + // and when new projects are created or loaded at startup. + boolean refresh = false; + + int eventType = event.getEventType(); + + if (eventType == CProjectDescriptionEvent.APPLIED) { + + synchronized (executablesMap) { + // see if the active build config has changed + ICProjectDescription newDesc = event.getNewCProjectDescription(); + ICProjectDescription oldDesc = event.getOldCProjectDescription(); + if (oldDesc != null && newDesc != null) { + String newConfigName = newDesc.getActiveConfiguration().getName(); + String oldConfigName = oldDesc.getActiveConfiguration().getName(); + if (!newConfigName.equals(oldConfigName)) { + if (executablesMap.containsKey(newDesc.getProject())) { + executablesMap.remove(newDesc.getProject()); + refresh = true; + + trace("Scheduling refresh because active build configuration changed"); //$NON-NLS-1$ + } + } + } else if (newDesc != null && oldDesc == null) { + // project just created + refresh = true; + + trace("Scheduling refresh because project " + newDesc.getProject().getName() + " created"); //$NON-NLS-1$//$NON-NLS-2$ + } + } + } + + if (refresh) { + scheduleRefresh(); + } + } + + private List getProjectsToCheck() { + + List projects = new ArrayList(); + + synchronized (executablesMap) { + // look for any CDT projects not in our cache + for (IProject project : ResourcesPlugin.getWorkspace().getRoot().getProjects()) { + if (!executablesMap.containsKey(project)) { + if (CoreModel.hasCNature(project)) { + projects.add(project); + } + } + } + } + + return projects; + } + + private void scheduleRefresh() { + trace("scheduleRefresh called at " + getStringFromTimestamp(System.currentTimeMillis())); //$NON-NLS-1$ + + refreshJob.cancel(); + refreshJob.schedule(); + } + + private IProjectExecutablesProvider getExecutablesProviderForProject(IProject project) { + IProjectExecutablesProvider provider = executablesProviderMap.get(project); + if (provider == null) { + // not cached yet. get the list of project natures from the providers and + // pick the one with the closest match + try { + IProjectDescription description = project.getDescription(); + int mostNaturesMatched = 0; + for (IProjectExecutablesProvider exeProvider : executableProviders) { + List natures = exeProvider.getProjectNatures(); + + int naturesMatched = 0; + for (String nature : description.getNatureIds()) { + if (natures.contains(nature)) { + naturesMatched++; + } + } + + if (naturesMatched > mostNaturesMatched) { + provider = exeProvider; + mostNaturesMatched = naturesMatched; + } + } + + // cache it + executablesProviderMap.put(project, provider); + + } catch (CoreException e) { + e.printStackTrace(); + } + } + + return provider; + } + + private void loadExecutableProviderExtensions() { + executableProviders = Collections.synchronizedList(new ArrayList()); + + IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = extensionRegistry.getExtensionPoint(CDebugCorePlugin.PLUGIN_ID + ".ExecutablesProvider"); //$NON-NLS-1$ + IExtension[] extensions = extensionPoint.getExtensions(); + + for (int i = 0; i < extensions.length; i++) { + IExtension extension = extensions[i]; + IConfigurationElement[] elements = extension.getConfigurationElements(); + IConfigurationElement element = elements[0]; + + boolean failed = false; + try { + Object extObject = element.createExecutableExtension("class"); //$NON-NLS-1$ + if (extObject instanceof IProjectExecutablesProvider) { + executableProviders.add((IProjectExecutablesProvider)extObject); + } else { + failed = true; + } + } + catch (CoreException e) { + failed = true; + } + + if (failed) { + CDebugCorePlugin.log("Unable to load ExecutablesProvider extension from " + extension.getContributor().getName()); //$NON-NLS-1$ + } + } + } + + private void loadSoureFileProviderExtensions() { + sourceFileProviders = Collections.synchronizedList(new ArrayList()); + + IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = extensionRegistry.getExtensionPoint(CDebugCorePlugin.PLUGIN_ID + ".SourceFilesProvider"); //$NON-NLS-1$ + IExtension[] extensions = extensionPoint.getExtensions(); + + for (int i = 0; i < extensions.length; i++) { + IExtension extension = extensions[i]; + IConfigurationElement[] elements = extension.getConfigurationElements(); + IConfigurationElement element = elements[0]; + + boolean failed = false; + try { + Object extObject = element.createExecutableExtension("class"); //$NON-NLS-1$ + if (extObject instanceof ISourceFilesProvider) { + sourceFileProviders.add((ISourceFilesProvider)extObject); + } else { + failed = true; + } + } + catch (CoreException e) { + failed = true; + } + + if (failed) { + CDebugCorePlugin.log("Unable to load SourceFilesProvider extension from " + extension.getContributor().getName()); //$NON-NLS-1$ + } + } + } + + private void loadSoureRemappingExtensions() { + sourceFileRemappings = Collections.synchronizedList(new ArrayList()); + + IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = extensionRegistry.getExtensionPoint(CDebugCorePlugin.PLUGIN_ID + ".SourceRemappingProvider"); //$NON-NLS-1$ + IExtension[] extensions = extensionPoint.getExtensions(); + + for (int i = 0; i < extensions.length; i++) { + IExtension extension = extensions[i]; + IConfigurationElement[] elements = extension.getConfigurationElements(); + IConfigurationElement element = elements[0]; + + boolean failed = false; + try { + Object extObject = element.createExecutableExtension("class"); //$NON-NLS-1$ + if (extObject instanceof ISourceFileRemapping) { + sourceFileRemappings.add((ISourceFileRemapping)extObject); + } else { + failed = true; + } + } + catch (CoreException e) { + failed = true; + } + + if (failed) { + CDebugCorePlugin.log("Unable to load SourceRemappingProvider extension from " + extension.getContributor().getName()); //$NON-NLS-1$ + } + } + } + + private void loadExecutableImporterExtensions() { + executableImporters = Collections.synchronizedList(new ArrayList()); + + IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = extensionRegistry.getExtensionPoint(CDebugCorePlugin.PLUGIN_ID + ".ExecutablesImporter"); //$NON-NLS-1$ + IExtension[] extensions = extensionPoint.getExtensions(); + + for (int i = 0; i < extensions.length; i++) { + IExtension extension = extensions[i]; + IConfigurationElement[] elements = extension.getConfigurationElements(); + IConfigurationElement element = elements[0]; + + boolean failed = false; + try { + Object extObject = element.createExecutableExtension("class"); //$NON-NLS-1$ + if (extObject instanceof IExecutableImporter) { + executableImporters.add((IExecutableImporter)extObject); + } else { + failed = true; + } + } + catch (CoreException e) { + failed = true; + } + + if (failed) { + CDebugCorePlugin.log("Unable to load ExecutablesImporter extension from " + extension.getContributor().getName()); //$NON-NLS-1$ + } + } + } + + private void trace(String msg) { + if (DEBUG) { + // TODO use Logger? + System.out.println(msg); + } + } + + private String getStringFromTimestamp(long timestamp) { + return DateFormat.getTimeInstance(DateFormat.MEDIUM).format(new Date(timestamp)); + } +} diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutableImporter.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutableImporter.java index 619664faf6d..a864eb11073 100644 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutableImporter.java +++ b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutableImporter.java @@ -42,6 +42,6 @@ public interface IExecutableImporter { /** * @since 6.0 */ - public abstract boolean importExecutables(String[] fileNames, IProgressMonitor monitor); + public boolean importExecutables(String[] fileNames, IProgressMonitor monitor); } \ No newline at end of file diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutableProvider.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutableProvider.java deleted file mode 100644 index 7b798f7e1ef..00000000000 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutableProvider.java +++ /dev/null @@ -1,59 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2008 Nokia 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 - * - * Contributors: - * Nokia - Initial API and implementation - *******************************************************************************/ -package org.eclipse.cdt.debug.core.executables; - -import org.eclipse.core.runtime.IProgressMonitor; -import org.eclipse.core.runtime.IStatus; - -/** - * IExecutablesProvider supplies a list of executables to the Executables - * Manager. - * - * @author Ken Ryall - * - */ -public interface IExecutableProvider { - - /** - * @since 6.0 - */ - public static final int LOW_PRIORITY = 25; - /** - * @since 6.0 - */ - public static final int NORMAL_PRIORITY = 50; - /** - * @since 6.0 - */ - public static final int HIGH_PRIORITY = 75; - - /** - * Gets the priority to be used when providing a list of executables. - * The priority is used by the Executables Manager when multiple IExecutableProvider are available. - * IExecutableImporter.importExecutables will be called for each one in priority order. - * - * @param executable - * @return the priority level to be used for this ISourceFilesProvider - * @since 6.0 - */ - int getPriority(); - - /** - * @since 6.0 - */ - Executable[] getExecutables(IProgressMonitor monitor); - - /** - * @since 6.0 - */ - IStatus removeExecutable(Executable executable, IProgressMonitor monitor); - -} \ No newline at end of file diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutablesChangeEvent.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutablesChangeEvent.java deleted file mode 100644 index 9c7cab2285c..00000000000 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutablesChangeEvent.java +++ /dev/null @@ -1,26 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2008 Nokia 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 - * - * Contributors: - * Nokia - Initial API and implementation - *******************************************************************************/ - -package org.eclipse.cdt.debug.core.executables; - - -public interface IExecutablesChangeEvent { - - /** - * @since 6.0 - */ - public Executable[] getCurrentExecutables(); - - /** - * @since 6.0 - */ - public Executable[] getPreviousExecutables(); -} \ No newline at end of file diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutablesChangeListener.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutablesChangeListener.java index bfa0677655f..a039b48678e 100644 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutablesChangeListener.java +++ b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IExecutablesChangeListener.java @@ -12,9 +12,23 @@ package org.eclipse.cdt.debug.core.executables; import java.util.EventListener; +import java.util.List; public interface IExecutablesChangeListener extends EventListener { - public void executablesChanged(IExecutablesChangeEvent event); + /** + * Called whenever the list of executables in the workspace changes, e.g. a + * project was opened/closed/created/deleted + * @since 7.0 + */ + public void executablesListChanged(); + /** + * Called whenever some executables have changed, e.g. when a project is rebuilt or + * cleaned. The content may have changed for example, so the list of source files + * may be different. + * @param executables + * @since 7.0 + */ + public void executablesChanged(List executables); } \ No newline at end of file diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IProjectExecutablesProvider.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IProjectExecutablesProvider.java new file mode 100644 index 00000000000..82044353b78 --- /dev/null +++ b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/IProjectExecutablesProvider.java @@ -0,0 +1,54 @@ +/******************************************************************************* + * Copyright (c) 2009 Nokia 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 + * + * Contributors: + * Nokia - Initial API and implementation + *******************************************************************************/ +package org.eclipse.cdt.debug.core.executables; + +import java.util.List; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; + +/** + * IProjectExecutablesProvider supplies a list of executables for a project + * to the Executables Manager. + * + * @author Warren Paul + * @since 7.0 + * + */ +public interface IProjectExecutablesProvider { + + /** + * Get the list of project natures that should be present in projects that + * this provider will get the list of executables for. Since there could + * be any number of executable providers, the one that matches the given + * project natures the closest will be chosen. + * @return the list of project nature id's + */ + List getProjectNatures(); + + /** + * Get the list of executables for the given project + * @param project the project to get the executables for + * @param monitor progress monitor + * @return the list of executables (which may be empty) + */ + List getExecutables(IProject project, IProgressMonitor monitor); + + /** + * Remove the given executable. Note that the project can be obtained from Executable. + * @param executable the executable to remove + * @param monitor progress monitor + * @return the status of the remove operation + */ + IStatus removeExecutable(Executable executable, IProgressMonitor monitor); + +} diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/ISourceFileRemapping.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/ISourceFileRemapping.java index 23222b52ace..0f0667e7668 100644 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/ISourceFileRemapping.java +++ b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/ISourceFileRemapping.java @@ -10,6 +10,7 @@ *******************************************************************************/ package org.eclipse.cdt.debug.core.executables; +import org.eclipse.core.runtime.IPath; /** * ISourceFileRemapping is used by the Executables Manager when finding missing @@ -21,8 +22,8 @@ package org.eclipse.cdt.debug.core.executables; public interface ISourceFileRemapping { /** - * @since 6.0 + * @since 7.0 */ - String remapSourceFile(Executable executable, String filePath); + String remapSourceFile(IPath executable, String filePath); } \ No newline at end of file diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/StandardExecutableProvider.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/StandardExecutableProvider.java new file mode 100644 index 00000000000..67ab7b1c2dc --- /dev/null +++ b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/core/executables/StandardExecutableProvider.java @@ -0,0 +1,91 @@ +/******************************************************************************* + * Copyright (c) 2008 Nokia 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 + * + * Contributors: + * Nokia - Initial API and implementation + *******************************************************************************/ + +package org.eclipse.cdt.debug.core.executables; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.cdt.core.CCProjectNature; +import org.eclipse.cdt.core.CProjectNature; +import org.eclipse.cdt.core.model.CModelException; +import org.eclipse.cdt.core.model.IBinary; +import org.eclipse.cdt.core.model.ICProject; +import org.eclipse.cdt.debug.core.CDebugCorePlugin; +import org.eclipse.cdt.internal.core.model.CModelManager; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.core.runtime.SubMonitor; +import org.eclipse.debug.core.DebugPlugin; + +/** + * @since 7.0 + */ +public class StandardExecutableProvider implements IProjectExecutablesProvider { + + List supportedNatureIds = new ArrayList(); + + public StandardExecutableProvider() { + supportedNatureIds.add(CProjectNature.C_NATURE_ID); + supportedNatureIds.add(CCProjectNature.CC_NATURE_ID); + } + + public List getProjectNatures() { + return supportedNatureIds; + } + + public List getExecutables(IProject project, IProgressMonitor monitor) { + List executables = new ArrayList(); + + ICProject cproject = CModelManager.getDefault().create(project); + try { + IBinary[] binaries = cproject.getBinaryContainer().getBinaries(); + + SubMonitor progress = SubMonitor.convert(monitor, binaries.length); + + for (IBinary binary : binaries) { + if (progress.isCanceled()) { + break; + } + + if (binary.isExecutable() || binary.isSharedLib()) { + IPath exePath = binary.getResource().getLocation(); + if (exePath == null) + exePath = binary.getPath(); + executables.add(new Executable(exePath, project, binary.getResource())); + } + + progress.worked(1); + } + } catch (CModelException e) { + } + + return executables; + } + + public IStatus removeExecutable(Executable executable, IProgressMonitor monitor) { + IResource exeResource = executable.getResource(); + if (exeResource != null) { + try { + exeResource.delete(true, monitor); + } catch (CoreException e) { + DebugPlugin.log( e ); + } + return Status.OK_STATUS; + } + return new Status(IStatus.WARNING, CDebugCorePlugin.PLUGIN_ID, "Can't remove " + executable.getName() + ": it is built by project \"" + executable.getProject().getName() + "\""); //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$ + } +} diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/ExecutablesChangeEvent.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/ExecutablesChangeEvent.java deleted file mode 100644 index 9ac64ad6bec..00000000000 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/ExecutablesChangeEvent.java +++ /dev/null @@ -1,35 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2008 Nokia 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 - * - * Contributors: - * Nokia - Initial API and implementation - *******************************************************************************/ -package org.eclipse.cdt.debug.internal.core.executables; - -import org.eclipse.cdt.debug.core.executables.Executable; -import org.eclipse.cdt.debug.core.executables.IExecutablesChangeEvent; -import org.eclipse.core.runtime.PlatformObject; - -public class ExecutablesChangeEvent extends PlatformObject implements IExecutablesChangeEvent { - - private Executable[] oldExecutables; - private Executable[] newExecutables; - - public ExecutablesChangeEvent(Executable[] oldList, Executable[] newList) { - oldExecutables = oldList; - newExecutables = newList; - } - - public Executable[] getCurrentExecutables() { - return newExecutables; - } - - public Executable[] getPreviousExecutables() { - return oldExecutables; - } - -} diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardExecutableImporter.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardExecutableImporter.java index 063c7da62f2..8cec63595bb 100644 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardExecutableImporter.java +++ b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardExecutableImporter.java @@ -59,7 +59,7 @@ public class StandardExecutableImporter implements IExecutableImporter { * org.eclipse.core.runtime.IProgressMonitor) */ public boolean importExecutables(String[] fileNames, IProgressMonitor monitor) { - monitor.beginTask("Import Executables", fileNames.length); + monitor.beginTask("Import Executables", fileNames.length); //$NON-NLS-1$ IProject exeProject = null; boolean checkProject = false; @@ -74,7 +74,7 @@ public class StandardExecutableImporter implements IExecutableImporter { if (AllowImport(Path.fromOSString(path))) { if (!checkProject) { // See if the default project exists - String defaultProjectName = "Executables"; + String defaultProjectName = "Executables"; //$NON-NLS-1$ ICProject cProject = CoreModel.getDefault().getCModel().getCProject(defaultProjectName); if (cProject.exists()) { exeProject = cProject.getProject(); @@ -184,8 +184,8 @@ public class StandardExecutableImporter implements IExecutableImporter { private boolean isExtensionVisible(IExtension ext) { IConfigurationElement[] elements = ext.getConfigurationElements(); - for (int i = 0; i < elements.length; i++) { - IConfigurationElement[] children = elements[i].getChildren("filter"); //$NON-NLS-1$ + for (IConfigurationElement element : elements) { + IConfigurationElement[] children = element.getChildren("filter"); //$NON-NLS-1$ for (int j = 0; j < children.length; j++) { String name = children[j].getAttribute("name"); //$NON-NLS-1$ if (name != null && name.equals("visibility")) { //$NON-NLS-1$ @@ -208,7 +208,7 @@ public class StandardExecutableImporter implements IExecutableImporter { IConfigurationElement[] children = elements[i].getChildren("run"); //$NON-NLS-1$ for (int j = 0; j < children.length; j++) { try { - parser = (IBinaryParser) children[j].createExecutableExtension("class"); + parser = (IBinaryParser) children[j].createExecutableExtension("class"); //$NON-NLS-1$ } catch (CoreException e) { CDebugCorePlugin.log(e); } diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardExecutableProvider.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardExecutableProvider.java deleted file mode 100644 index 3f8542b73f0..00000000000 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardExecutableProvider.java +++ /dev/null @@ -1,194 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2008 Nokia 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 - * - * Contributors: - * Nokia - Initial API and implementation - *******************************************************************************/ - -package org.eclipse.cdt.debug.internal.core.executables; - -import java.util.ArrayList; - -import org.eclipse.cdt.core.model.CModelException; -import org.eclipse.cdt.core.model.CoreModel; -import org.eclipse.cdt.core.model.IBinary; -import org.eclipse.cdt.core.model.ICProject; -import org.eclipse.cdt.core.settings.model.CProjectDescriptionEvent; -import org.eclipse.cdt.core.settings.model.ICProjectDescription; -import org.eclipse.cdt.core.settings.model.ICProjectDescriptionListener; -import org.eclipse.cdt.debug.core.CDebugCorePlugin; -import org.eclipse.cdt.debug.core.executables.Executable; -import org.eclipse.cdt.debug.core.executables.ExecutablesManager; -import org.eclipse.cdt.debug.core.executables.IExecutableProvider; -import org.eclipse.cdt.internal.core.model.CModelManager; -import org.eclipse.core.resources.IProject; -import org.eclipse.core.resources.IResource; -import org.eclipse.core.resources.IResourceChangeEvent; -import org.eclipse.core.resources.IResourceChangeListener; -import org.eclipse.core.resources.IResourceDelta; -import org.eclipse.core.resources.IResourceDeltaVisitor; -import org.eclipse.core.resources.IWorkspaceRoot; -import org.eclipse.core.resources.ResourcesPlugin; -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IPath; -import org.eclipse.core.runtime.IProgressMonitor; -import org.eclipse.core.runtime.IStatus; -import org.eclipse.core.runtime.Status; -import org.eclipse.debug.core.DebugPlugin; - -public class StandardExecutableProvider implements IResourceChangeListener, ICProjectDescriptionListener, IExecutableProvider { - - private ArrayList executables = new ArrayList(); - - public StandardExecutableProvider() { - ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE); - CoreModel.getDefault().getProjectDescriptionManager().addCProjectDescriptionListener(this, - CProjectDescriptionEvent.DATA_APPLIED | CProjectDescriptionEvent.LOADED); - } - - public void resourceChanged(IResourceChangeEvent event) { - - // refresh when projects are opened or closed. note that deleted - // projects are handled later - // in this method. new projects are handled in handleEvent. - // resource changed events always start at the workspace root, so - // projects - // are the next level down - IResourceDelta[] projects = event.getDelta().getAffectedChildren(); - for (IResourceDelta projectDelta : projects) { - if ((projectDelta.getFlags() & IResourceDelta.OPEN) != 0) { - if (projectDelta.getKind() == IResourceDelta.CHANGED) { - // project was opened or closed - ExecutablesManager.getExecutablesManager().scheduleRefresh(this, 0); - return; - } - } - } - - try { - final StandardExecutableProvider provider = this; - event.getDelta().accept(new IResourceDeltaVisitor() { - - public boolean visit(IResourceDelta delta) throws CoreException { - if (delta.getKind() == IResourceDelta.ADDED || delta.getKind() == IResourceDelta.REMOVED) { - IResource deltaResource = delta.getResource(); - if (deltaResource != null) { - boolean refresh = false; - if (delta.getKind() == IResourceDelta.REMOVED && deltaResource instanceof IProject) { - // project deleted - refresh = true; - } else { - // see if a binary has been added/removed - IPath resourcePath = delta.getResource().getLocation(); - if (resourcePath != null && Executable.isExecutableFile(resourcePath)) { - refresh = true; - } - } - if (refresh) { - ExecutablesManager.getExecutablesManager().scheduleRefresh(provider, 0); - return false; - } - } - } - return true; - } - }); - } catch (CoreException e) { - } - } - - public void handleEvent(CProjectDescriptionEvent event) { - // this handles the cases where the active build configuration changes, - // and when new - // projects are created. - boolean refresh = false; - - int eventType = event.getEventType(); - - if (eventType == CProjectDescriptionEvent.DATA_APPLIED) { - // see if the active build config has changed - ICProjectDescription newDesc = event.getNewCProjectDescription(); - ICProjectDescription oldDesc = event.getOldCProjectDescription(); - if (oldDesc != null && newDesc != null) { - String newConfigName = newDesc.getActiveConfiguration().getName(); - String oldConfigName = oldDesc.getActiveConfiguration().getName(); - refresh = (!newConfigName.equals(oldConfigName)); - } else if (newDesc != null && oldDesc == null) { - // project just created - refresh = true; - } - } - - if (refresh) { - ExecutablesManager.getExecutablesManager().scheduleRefresh(this, 0); - } - } - - public Executable[] getExecutables(IProgressMonitor monitor) { - synchronized (executables) { - executables.clear(); - - IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); - IProject[] projects = root.getProjects(); - - monitor.beginTask("Checking C/C++ Projects", projects.length); - - for (IProject project : projects) { - - if (monitor.isCanceled()) - break; - - try { - if (CoreModel.hasCNature(project)) { - CModelManager manager = CModelManager.getDefault(); - ICProject cproject = manager.create(project); - try { - IBinary[] binaries = cproject.getBinaryContainer().getBinaries(); - for (IBinary binary : binaries) { - if (binary.isExecutable() || binary.isSharedLib()) { - IPath exePath = binary.getResource().getLocation(); - if (exePath == null) - exePath = binary.getPath(); - Executable exe = new Executable(exePath, project, binary.getResource()); - executables.add(exe); - } - } - } catch (CModelException e) { - } - } - } catch (Exception e) { - DebugPlugin.log( e ); - } - monitor.worked(1); - } - monitor.done(); - } - return executables.toArray(new Executable[executables.size()]); - } - - public int getPriority() { - return NORMAL_PRIORITY; - } - - public IStatus removeExecutable(Executable executable, IProgressMonitor monitor) { - IResource exeResource = executable.getResource(); - if (exeResource != null) - { - if (exeResource.isLinked()) - { - try { - exeResource.delete(true, monitor); - } catch (CoreException e) { - DebugPlugin.log( e ); - } - } - return Status.OK_STATUS; - } - return new Status(IStatus.WARNING, CDebugCorePlugin.PLUGIN_ID, "Can't remove " + executable.getName() + ": it is built by project \"" + executable.getProject().getName() + "\""); - } - -} \ No newline at end of file diff --git a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardSourceFileRemapping.java b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardSourceFileRemapping.java index 150fe0c2cfd..b5902c16687 100644 --- a/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardSourceFileRemapping.java +++ b/debug/org.eclipse.cdt.debug.core/src/org/eclipse/cdt/debug/internal/core/executables/StandardSourceFileRemapping.java @@ -12,11 +12,11 @@ package org.eclipse.cdt.debug.internal.core.executables; import org.eclipse.cdt.debug.core.CDebugCorePlugin; -import org.eclipse.cdt.debug.core.executables.Executable; import org.eclipse.cdt.debug.core.executables.ISourceFileRemapping; import org.eclipse.cdt.debug.core.sourcelookup.ICSourceLocator; import org.eclipse.cdt.debug.internal.core.sourcelookup.CSourceLookupDirector; import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; import org.eclipse.debug.core.DebugPlugin; import org.eclipse.debug.core.ILaunch; import org.eclipse.debug.core.ILaunchManager; @@ -25,7 +25,7 @@ import org.eclipse.debug.core.sourcelookup.containers.LocalFileStorage; public class StandardSourceFileRemapping implements ISourceFileRemapping { - public String remapSourceFile(Executable executable, String filePath) { + public String remapSourceFile(IPath executable, String filePath) { try { Object[] foundElements = CDebugCorePlugin.getDefault().getCommonSourceLookupDirector().findSourceElements(filePath); diff --git a/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesContentProvider.java b/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesContentProvider.java index b16caff7fd1..de6f54db024 100644 --- a/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesContentProvider.java +++ b/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesContentProvider.java @@ -17,9 +17,6 @@ import java.util.Date; import org.eclipse.cdt.debug.core.executables.Executable; import org.eclipse.cdt.debug.core.executables.ExecutablesManager; import org.eclipse.core.runtime.IPath; -import org.eclipse.core.runtime.IProgressMonitor; -import org.eclipse.core.runtime.IStatus; -import org.eclipse.core.runtime.jobs.Job; import org.eclipse.jface.viewers.ColumnLabelProvider; import org.eclipse.jface.viewers.IStructuredContentProvider; import org.eclipse.jface.viewers.ITreeContentProvider; @@ -29,10 +26,7 @@ import org.eclipse.jface.viewers.ViewerCell; class ExecutablesContentProvider extends ColumnLabelProvider implements IStructuredContentProvider, ITreeContentProvider { - private TreeViewer viewer; - public ExecutablesContentProvider(TreeViewer viewer) { - this.viewer = viewer; } public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { @@ -43,42 +37,8 @@ class ExecutablesContentProvider extends ColumnLabelProvider implements IStructu public Object[] getElements(final Object inputElement) { if (inputElement instanceof ExecutablesManager) { - final ExecutablesManager em = (ExecutablesManager) inputElement; - if (em.refreshNeeded()) { - // do this asynchronously. just return an empty array - // immediately, and then refresh the view - // once the list of executables has been calculated. this can - // take a while and we don't want - // to block the UI. - Job refreshJob = new Job(Messages.ExecutablesContentProvider_FetchingExecutables) { - - @Override - protected IStatus run(IProgressMonitor monitor) { - IStatus status = em.refreshExecutables(monitor); - - // Are we in the UIThread? If so spin it until we are done - if (!viewer.getControl().isDisposed()) { - if (viewer.getControl().getDisplay().getThread() == Thread.currentThread()) { - viewer.refresh(inputElement); - } else { - viewer.getControl().getDisplay().asyncExec(new Runnable() { - public void run() { - viewer.refresh(inputElement); - } - }); - } - } - - monitor.done(); - return status; - } - }; - - refreshJob.schedule(); - - } else { - return em.getExecutables(); - } + ExecutablesManager em = (ExecutablesManager) inputElement; + return em.getExecutables().toArray(); } return new Object[] {}; } diff --git a/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesView.java b/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesView.java index 2a7abb600b1..01157a7bb89 100644 --- a/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesView.java +++ b/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesView.java @@ -225,6 +225,8 @@ public class ExecutablesView extends ViewPart { private Action configureColumnsAction; private IMemento memento; + + private IStructuredSelection oldSelection; /** * Create contents of the Executables View @@ -239,9 +241,9 @@ public class ExecutablesView extends ViewPart { final SashForm sashForm = new SashForm(container, SWT.NONE); // Create the two sub viewers. - executablesViewer = new ExecutablesViewer(this, sashForm, SWT.FULL_SELECTION + SWT.BORDER + SWT.MULTI); + executablesViewer = new ExecutablesViewer(this, sashForm, SWT.FULL_SELECTION | SWT.BORDER | SWT.MULTI); ExecutablesManager.getExecutablesManager().addExecutablesChangeListener(executablesViewer); - sourceFilesViewer = new SourceFilesViewer(this, sashForm, SWT.BORDER); + sourceFilesViewer = new SourceFilesViewer(this, sashForm, SWT.BORDER | SWT.MULTI); sashForm.setWeights(new int[] { 1, 1 }); @@ -271,30 +273,39 @@ public class ExecutablesView extends ViewPart { public void selectionChanged(SelectionChangedEvent event) { ISelection newSelection = event.getSelection(); if (newSelection instanceof IStructuredSelection) { - final Object firstElement = ((IStructuredSelection) newSelection).getFirstElement(); - Job setectExeJob = new Job(Messages.ExecutablesView_Select_Executable) { + if (oldSelection == null || !oldSelection.equals(newSelection)) + { + // update the remove action + removeAction.setEnabled(!newSelection.isEmpty()); + + final Object firstElement = ((IStructuredSelection) newSelection).getFirstElement(); + + Job setectExeJob = new Job(Messages.ExecutablesView_Select_Executable) { - @Override - protected IStatus run(IProgressMonitor monitor) { - if (firstElement instanceof Executable) { - Executable executable = (Executable)firstElement; - this.setName(Messages.ExecutablesView_Finding_Sources_Job_Name + executable.getName()); - executable.getSourceFiles(monitor); - } - UIJob selectExeUIJob = new UIJob(Messages.ExecutablesView_Select_Executable){ - @Override - public IStatus runInUIThread(IProgressMonitor monitor) { - sourceFilesViewer.setInput(firstElement); - if (firstElement instanceof Executable) { + @Override + protected IStatus run(IProgressMonitor monitor) { + if (firstElement instanceof Executable) { + Executable executable = (Executable)firstElement; + this.setName(Messages.ExecutablesView_Finding_Sources_Job_Name + executable.getName()); + executable.getSourceFiles(monitor); + } + // selection could be empty, so do this no matter what to update the source + // files viewer + UIJob selectExeUIJob = new UIJob(Messages.ExecutablesView_Select_Executable){ + @Override + public IStatus runInUIThread(IProgressMonitor monitor) { + sourceFilesViewer.setInput(firstElement); sourceFilesViewer.packColumns(); - } - return Status.OK_STATUS; - }}; + return Status.OK_STATUS; + }}; selectExeUIJob.schedule(); return Status.OK_STATUS; - }}; + }}; setectExeJob.schedule(); + oldSelection = (IStructuredSelection) newSelection; + } + } } }); @@ -360,6 +371,7 @@ public class ExecutablesView extends ViewPart { private Action createRemoveAction() { Action action = new Action("Remove") { + public void run() { ISelection selection = getExecutablesViewer().getSelection(); if (selection instanceof IStructuredSelection) @@ -404,7 +416,7 @@ public class ExecutablesView extends ViewPart { action.setToolTipText("Remove the selected executables"); action.setImageDescriptor(ExecutablesView.DESC_REMOVE); action.setDisabledImageDescriptor(ExecutablesView.DESC_REMOVE_DISABLED); - action.setEnabled(true); + action.setEnabled(false); return action; } @@ -460,7 +472,7 @@ public class ExecutablesView extends ViewPart { private Action createRefreshAction() { Action action = new Action(Messages.ExecutablesView_Refresh) { public void run() { - ExecutablesManager.getExecutablesManager().scheduleRefresh(null, 0); + ExecutablesManager.getExecutablesManager().refresh(null); } }; action.setToolTipText(Messages.ExecutablesView_RefreshList); diff --git a/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesViewer.java b/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesViewer.java index cc44147ebe6..40ca8748195 100644 --- a/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesViewer.java +++ b/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/ExecutablesViewer.java @@ -10,9 +10,10 @@ *******************************************************************************/ package org.eclipse.cdt.debug.internal.ui.views.executables; +import java.util.List; + import org.eclipse.cdt.debug.core.executables.Executable; import org.eclipse.cdt.debug.core.executables.ExecutablesManager; -import org.eclipse.cdt.debug.core.executables.IExecutablesChangeEvent; import org.eclipse.cdt.debug.core.executables.IExecutablesChangeListener; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; @@ -166,39 +167,6 @@ public class ExecutablesViewer extends BaseViewer implements IExecutablesChangeL return new ExecutablesViewerComparator(sortType, column_sort_order[sortType]); } - /* - * (non-Javadoc) - * - * @see org.eclipse.cdt.debug.core.executables.IExecutablesChangeListener#executablesChanged(org.eclipse.cdt.debug.core.executables.IExecutablesChangeEvent) - */ - public void executablesChanged(IExecutablesChangeEvent event) { - // Executables have changed so refresh the view. - final ExecutablesViewer viewer = this; - UIJob refreshJob = new UIJob(Messages.ExecutablesViewer_RefreshExecutablesView) { - - @Override - public IStatus runInUIThread(IProgressMonitor monitor) { - // if the user has selected an executable, they expect its - // list of source files to be refreshed automatically - if (viewer.getSelection() != null && - viewer.getSelection() instanceof IStructuredSelection) { - IStructuredSelection selection = (IStructuredSelection) viewer.getSelection(); - - Object firstElement = selection.getFirstElement(); - if (firstElement instanceof Executable) { - Executable executable = (Executable)firstElement; - executable.setRefreshSourceFiles(true); - viewer.setSelection(selection); - } - } - viewer.refresh(null); - viewer.packColumns(); - return Status.OK_STATUS; - } - }; - refreshJob.schedule(); - } - @Override protected String getColumnOrderKey() { return P_COLUMN_ORDER_KEY_EXE; @@ -224,4 +192,46 @@ public class ExecutablesViewer extends BaseViewer implements IExecutablesChangeL // default visible columns return "1,1,1,0,0,0"; //$NON-NLS-1$ } + + public void executablesChanged(final List executables) { + // some executables have been updated. if one of them is currently + // selected, we need to update the source file list + UIJob refreshJob = new UIJob(Messages.ExecutablesViewer_RefreshExecutablesView) { + + @Override + public IStatus runInUIThread(IProgressMonitor monitor) { + // if the user has selected an executable, they expect its + // list of source files to be refreshed automatically + if (getSelection() != null && + getSelection() instanceof IStructuredSelection) { + IStructuredSelection selection = (IStructuredSelection)getSelection(); + + Object firstElement = selection.getFirstElement(); + if (firstElement instanceof Executable) { + Executable executable = (Executable) firstElement; + if (executables.contains(executable)) { + executable.setRefreshSourceFiles(true); + setSelection(selection); + } + } + } + return Status.OK_STATUS; + } + }; + refreshJob.schedule(); + } + + public void executablesListChanged() { + // Executables list has changed so refresh the view. + UIJob refreshJob = new UIJob(Messages.ExecutablesViewer_RefreshExecutablesView) { + + @Override + public IStatus runInUIThread(IProgressMonitor monitor) { + refresh(null); + packColumns(); + return Status.OK_STATUS; + } + }; + refreshJob.schedule(); + } } \ No newline at end of file diff --git a/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/SourceFilesLabelProvider.java b/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/SourceFilesLabelProvider.java index ed497aef281..85c1ecac0c1 100644 --- a/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/SourceFilesLabelProvider.java +++ b/debug/org.eclipse.cdt.debug.ui/src/org/eclipse/cdt/debug/internal/ui/views/executables/SourceFilesLabelProvider.java @@ -70,7 +70,7 @@ public class SourceFilesLabelProvider extends TreeColumnViewerLabelProvider { if (cell.getElement() instanceof ITranslationUnit) { Executable executable = (Executable) viewer.getInput(); Path path = new Path(executable.getOriginalLocation((ITranslationUnit) cell.getElement())); - cell.setText(executable.getOriginalLocation((ITranslationUnit) cell.getElement())); + cell.setText(path.toOSString()); if (path.toFile().exists()) cell.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK)); else