public class ExecutablesManager extends PlatformObject implements IResourceChangeListener, ICProjectDescriptionListener {

	private static final String EXECUTABLES_MANAGER_DEBUG_TRACING = CDebugCorePlugin.PLUGIN_ID + "EXECUTABLES_MANAGER_DEBUG_TRACING"; //$NON-NLS-1$

	private Map<IProject, IProjectExecutablesProvider> executablesProviderMap = new HashMap<IProject, IProjectExecutablesProvider>();

	private Map<IProject, List<Executable>> executablesMap = new HashMap<IProject, List<Executable>>();

	private List<IExecutablesChangeListener> changeListeners = Collections.synchronizedList(new ArrayList<IExecutablesChangeListener>());

	private List<IProjectExecutablesProvider> executableProviders;

	private List<ISourceFilesProvider> sourceFileProviders;

	private List<ISourceFileRemapping> sourceFileRemappings;

	private List<IExecutableImporter> executableImporters;

	private Job refreshJob = new Job("Get Executables") {

			trace("Get Executables job started at " + getStringFromTimestamp(System.currentTimeMillis()));

			List<IProject> projects = getProjectsToCheck();

			SubMonitor subMonitor = SubMonitor.convert(monitor, projects.size());

					trace("Get Executables job cancelled at " + getStringFromTimestamp(System.currentTimeMillis()));

					trace("Getting executables for project: " + project.getName() + " using " + provider.toString());

						executablesMap.put(project, provider.getExecutables(project, subMonitor.newChild(1, SubMonitor.SUPPRESS_NONE)));

			trace("Get Executables job finished at " + getStringFromTimestamp(System.currentTimeMillis()));

	/**

	 * Get the executables manager instance

	 * @return the executables manager

	 */

		// 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.DATA_APPLIED);

		// schedule a refresh so we get up to date

	/**

	 * Adds an executable listener

	 */

	/**

	 * Removes an executable listener

	 * @param listener the listener to remove

	 */

	 * 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

	public Collection<Executable> getExecutables(boolean wait) {

		trace("getExecutables called at " + getStringFromTimestamp(System.currentTimeMillis()));

		if (wait && refreshJob.getState() != Job.NONE) {

			trace("waiting for refresh job to finish at " + getStringFromTimestamp(System.currentTimeMillis()));

			try {

				refreshJob.join();

			} catch (InterruptedException e) {

			}

			trace("refresh job finished at " + getStringFromTimestamp(System.currentTimeMillis()));

		}

		trace("getExecutables returned at " + getStringFromTimestamp(System.currentTimeMillis()));

	 * 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

	 */

	public Collection<Executable> getExecutables() {

		return getExecutables(false);

	}

	/**

	 * @since 6.0

	 * Gets the collection of executables for the given project

	 * @param project the project

	 * @return collection of executables which may be empty

	 */

	}

	/**

	 * 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

	 */

				String remappedPath = remapping.remapSourceFile(executable.getPath(), filePath);

	/**

	 * Import the given executables into the manager

	 * @param fileNames the absolute paths of the executables to import

	 * @param monitor progress monitor

	 */

		monitor.beginTask("Import Executables", executableImporters.size());

		synchronized (executableImporters) {

			Collections.sort(executableImporters, new Comparator<IExecutableImporter>() {

				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;

				}

			}

		if (handled)

			scheduleRefresh();

	/**

	 * 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 boolean executableExists(IPath exePath) {

		synchronized (executablesMap) {

			for (List<Executable> exes : executablesMap.values()) {

				for (Executable exe : exes) {

					if (exe.getPath().equals(exePath)) {

						return true;

					}

		}

		return false;

	}

	/**

	 * 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) {

		String[] result = new String[0];

		trace("getSourceFiles called at " + getStringFromTimestamp(System.currentTimeMillis()) + " for " + executable.getPath().toOSString());

	/**

	 * 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) {

		MultiStatus status = new MultiStatus(CDebugCorePlugin.PLUGIN_ID, IStatus.WARNING, "Couldn't remove all of the selected executables", null);

			IProjectExecutablesProvider provider = getExecutablesProviderForProject(executable.getProject());

				IStatus result = provider.removeExecutable(executable, new SubProgressMonitor(monitor, 1));

					List<Executable> exes = executablesMap.get(executable.getProject());

	 * @param projects the list of projects, or null.  if null or the list

	 * is empty, all projects will be refreshed.

			// project needs to be refreshed after a build/clean as the binary may

					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<Executable> executables = executablesMap.remove(obj);

								trace("Scheduling refresh because project " + ((IProject)obj).getName() + " built or cleaned");

								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();

			// projects are handled later in this method. new projects are handled

			// in handleEvent.  resource changed events always start at the workspace

						if (executablesMap.containsKey(projectDelta.getResource())) {