dsf-gdb/org.eclipse.cdt.dsf.gdb/src/org/eclipse/cdt/dsf/gdb/launching/GdbSourceLookupDirector.java

/*******************************************************************************
 * Copyright (c) 2015 Kichwa Coders 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:
 *    Jonah Graham (Kichwa Coders) - initial API and implementation to Add support for gdb's "set substitute-path" (Bug 472765)
 *******************************************************************************/
package org.eclipse.cdt.dsf.gdb.launching;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.cdt.debug.core.sourcelookup.IMappingSourceContainer;
import org.eclipse.cdt.debug.core.sourcelookup.MappingSourceContainer;
import org.eclipse.cdt.debug.internal.core.sourcelookup.MapEntrySourceContainer;
import org.eclipse.cdt.dsf.debug.sourcelookup.DsfSourceLookupDirector;
import org.eclipse.cdt.dsf.gdb.service.IGDBSourceLookup;
import org.eclipse.cdt.dsf.service.DsfSession;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.debug.core.sourcelookup.ISourceContainer;
import org.eclipse.debug.core.sourcelookup.ISourceLookupParticipant;
import org.eclipse.debug.core.sourcelookup.containers.DefaultSourceContainer;

/**
 * A Source Lookup director that extends the standard DSF version to support the
 * GDB backend handling path substitutions using gdb's "set substitute-path"
 * mechanism. This director works in tandem with {@link IGDBSourceLookup}
 * service to synchronise GDB's path substitutions.
 * 
 * @since 5.0
 */
public class GdbSourceLookupDirector extends DsfSourceLookupDirector {
	private final DsfSession fSession;

	public GdbSourceLookupDirector(DsfSession session) {
		super(session);
		fSession = session;
	}

	@Override
	public void initializeParticipants() {
		/*
		 * We don't call super as we don't want DsfSourceLookupParticipant to be
		 * added explicitly. Instead we use GdbSourceLookupParticipant which
		 * extends DsfSourceLookupParticipant and does not use the mappings
		 * directly but relies on GDB's "set substitute-path".
		 */
		addParticipants(new ISourceLookupParticipant[] { new GdbSourceLookupParticipant(fSession) });
	}

	/**
	 * Return a map of substitutions with the Key being the compilation path and
	 * the Value being the machine local path.
	 * 
	 * @return map of substitutions
	 */
	public Map<String, String> getSubstitutionsPaths() {
		Map<String, String> entries = new HashMap<>();
		collectSubstitutionsPaths(getSourceContainers(), entries);
		return entries;
	}

	protected void collectSubstitutionsPaths(ISourceContainer[] containers, Map<String, String> entries) {
		for (ISourceContainer container : containers) {
			if (container instanceof MapEntrySourceContainer) {
				MapEntrySourceContainer sourceSubContainer = (MapEntrySourceContainer) container;

				String from = sourceSubContainer.getBackendPathStr();
				IPath to = sourceSubContainer.getLocalPath();
				if (from != null && to != null) {
					entries.put(from, to.toOSString());
				}
			} else if (container.isComposite()) {
				ISourceContainer[] childContainers;
				try {
					childContainers = container.getSourceContainers();
				} catch (CoreException e) {
					/*
					 * Consistent with other uses of getSourceContainers, we
					 * silently ignore these children.
					 */
					childContainers = new ISourceContainer[0];
				}
				if (container instanceof MappingSourceContainer) {
					MappingSourceContainer mappingSourceContainer = (MappingSourceContainer) container;
					if (mappingSourceContainer.isMappingWithBackendEnabled()) {
						collectSubstitutionsPaths(childContainers, entries);
					} else {
						/*
						 * This mapping has explicitly requested *not* to do a
						 * substitute, so don't recurse on children here.
						 */
					}
				} else {
					/*
					 * There can be MappingSourceContainers in
					 * DefaultSourceContainer, but not in other types of
					 * composite containers (e.g. a DirectorySourceContainer
					 * cannot contain a MappingSourceContainer).
					 * 
					 * It is important we don't recurse across all composites
					 * containers for performance reasons. If a
					 * DirectorySourceContainer was recursed here, then it could
					 * means recursing through the entire directory structure
					 * under that container.
					 */
					if (container instanceof DefaultSourceContainer) {
						collectSubstitutionsPaths(childContainers, entries);
					}
				}
			}
		}
	}

	/**
	 * Get the compilation path for the given sourceName. Unlike super's
	 * version, for {@link MappingSourceContainer}s where backend mapping is
	 * enabled this method is a no-op as in those cases the backend already
	 * matches.
	 */
	@Override
	public IPath getCompilationPath(String sourceName) {
		return getCompilationPath(getSourceContainers(), sourceName);
	}

	/**
	 * This method mirrors the logic of
	 * {@link #collectSubstitutionsPaths(ISourceContainer[], Map)} on which
	 * containers are iterated and excluded.
	 */
	protected IPath getCompilationPath(ISourceContainer[] containers, String sourceName) {
		for (ISourceContainer container : containers) {

			if (container instanceof IMappingSourceContainer) {
				IPath mappedPath = ((IMappingSourceContainer) container).getCompilationPath(sourceName);
				if (mappedPath != null) {
					if (container instanceof MappingSourceContainer
							&& ((MappingSourceContainer) container).isMappingWithBackendEnabled()) {
						/*
						 * This mapping is being handled by GDB backend (i.e. it was
						 * collected by collectSubstitutionsPaths to pass to gdb's
						 * "set substitute-path"). Because GDB is doing the
						 * translation on it, pass the local name to GDB, not the
						 * translated name.
						 */
						return new Path(sourceName);
					}
					return mappedPath;
				}
			} else if (container.isComposite()) {
				ISourceContainer[] childContainers = null;
				try {
					childContainers = container.getSourceContainers();
				} catch (CoreException e) {
					/*
					 * Consistent with other uses of getSourceContainers, we
					 * silently ignore these children.
					 */
				}
				if (childContainers != null) {
					IPath path = getCompilationPath(childContainers, sourceName);
					if (path != null) {
						return path;
					}
				}
			}
		}
		return null;
	}
}