ant/org.eclipse.ant.launching/src/org/eclipse/ant/internal/launching/debug/model/AntDebugTarget.java - platform/eclipse.platform - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004, 2016 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.ant.internal.launching.debug.model;

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;

 import org.eclipse.ant.internal.launching.debug.IAntDebugConstants;
 import org.eclipse.ant.internal.launching.debug.IAntDebugController;

 import org.eclipse.core.externaltools.internal.IExternalToolConstants;
 import org.eclipse.core.variables.VariablesPlugin;

 import org.eclipse.core.runtime.CoreException;

 import org.eclipse.core.resources.IMarkerDelta;

 import org.eclipse.debug.core.DebugEvent;
 import org.eclipse.debug.core.DebugException;
 import org.eclipse.debug.core.DebugPlugin;
 import org.eclipse.debug.core.IBreakpointManager;
 import org.eclipse.debug.core.IBreakpointManagerListener;
 import org.eclipse.debug.core.IDebugEventSetListener;
 import org.eclipse.debug.core.ILaunch;
 import org.eclipse.debug.core.model.IBreakpoint;
 import org.eclipse.debug.core.model.IDebugTarget;
 import org.eclipse.debug.core.model.ILineBreakpoint;
 import org.eclipse.debug.core.model.IMemoryBlock;
 import org.eclipse.debug.core.model.IProcess;
 import org.eclipse.debug.core.model.IThread;

 /**
  * Ant Debug Target
  */
 public class AntDebugTarget extends AntDebugElement implements IDebugTarget, IDebugEventSetListener, IBreakpointManagerListener {

 	// associated system process (Ant Build)
 	private IProcess fProcess;

 	// containing launch object
 	private ILaunch fLaunch;

 	// Build file name
 	private String fName;

 	// suspend state
 	private boolean fSuspended = false;

 	// terminated state
 	private boolean fTerminated = false;

 	// threads
 	private AntThread fThread;
 	private IThread[] fThreads;

 	private IAntDebugController fController;

 	private List<IBreakpoint> fRunToLineBreakpoints;

 	/**
 	 * Constructs a new debug target in the given launch for the associated Ant build process.
 	 *
 	 * @param launch
 	 *            containing launch
 	 * @param process
 	 *            Ant build process
 	 * @param controller
 	 *            the controller to communicate to the Ant build
 	 */
 	public AntDebugTarget(ILaunch launch, IProcess process, IAntDebugController controller) {
 		super(null);
 		fLaunch = launch;
 		fProcess = process;

 		fController = controller;

 		fThread = new AntThread(this);
 		fThreads = new IThread[] { fThread };

 		DebugPlugin.getDefault().getBreakpointManager().addBreakpointManagerListener(this);
 		DebugPlugin.getDefault().getBreakpointManager().addBreakpointListener(this);
 		DebugPlugin.getDefault().addDebugEventListener(this);
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDebugTarget#getProcess()
 	 */
 	@Override
 	public IProcess getProcess() {
 		return fProcess;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDebugTarget#getThreads()
 	 */
 	@Override
 	public IThread[] getThreads() {
 		return fThreads;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDebugTarget#hasThreads()
 	 */
 	@Override
 	public boolean hasThreads() throws DebugException {
 		return !fTerminated && fThreads.length > 0;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDebugTarget#getName()
 	 */
 	@Override
 	public String getName() throws DebugException {
 		if (fName == null) {
 			try {
 				fName = getLaunch().getLaunchConfiguration().getAttribute(IExternalToolConstants.ATTR_LOCATION, DebugModelMessages.AntDebugTarget_0);
 				fName = VariablesPlugin.getDefault().getStringVariableManager().performStringSubstitution(fName);
 			}
 			catch (CoreException e) {
 				fName = DebugModelMessages.AntDebugTarget_0;
 			}
 		}
 		return fName;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDebugTarget#supportsBreakpoint(org.eclipse.debug.core.model.IBreakpoint)
 	 */
 	@Override
 	public boolean supportsBreakpoint(IBreakpoint breakpoint) {
 		if (breakpoint.getModelIdentifier().equals(IAntDebugConstants.ID_ANT_DEBUG_MODEL)) {
 			// need to consider all breakpoints as no way to tell which set
 			// of build files will be executed (ant task)
 			return true;
 		}
 		return false;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDebugElement#getDebugTarget()
 	 */
 	@Override
 	public IDebugTarget getDebugTarget() {
 		return this;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDebugElement#getLaunch()
 	 */
 	@Override
 	public ILaunch getLaunch() {
 		return fLaunch;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.ITerminate#canTerminate()
 	 */
 	@Override
 	public boolean canTerminate() {
 		return !fTerminated;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.ITerminate#isTerminated()
 	 */
 	@Override
 	public boolean isTerminated() {
 		return fTerminated;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.ITerminate#terminate()
 	 */
 	@Override
 	public void terminate() throws DebugException {
 		terminated();
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.ISuspendResume#canResume()
 	 */
 	@Override
 	public boolean canResume() {
 		return !fTerminated && fSuspended;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.ISuspendResume#canSuspend()
 	 */
 	@Override
 	public boolean canSuspend() {
 		return !fTerminated && !fSuspended;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.ISuspendResume#isSuspended()
 	 */
 	@Override
 	public boolean isSuspended() {
 		return fSuspended;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.ISuspendResume#resume()
 	 */
 	@Override
 	public void resume() throws DebugException {
 		fSuspended = false;
 		fController.resume();
 		if (fThread.isSuspended()) {
 			fThread.resumedByTarget();
 		}
 		fireResumeEvent(DebugEvent.CLIENT_REQUEST);
 	}

 	/**
 	 * Notification the target has suspended for the given reason
 	 *
 	 * @param detail
 	 *            reason for the suspend
 	 */
 	public void suspended(int detail) {
 		fSuspended = true;
 		fThread.setStepping(false);
 		fThread.fireSuspendEvent(detail);
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.ISuspendResume#suspend()
 	 */
 	@Override
 	public void suspend() throws DebugException {
 		fController.suspend();
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.IBreakpointListener#breakpointAdded(org.eclipse.debug.core.model.IBreakpoint)
 	 */
 	@Override
 	public void breakpointAdded(IBreakpoint breakpoint) {
 		if (!fTerminated) {
 			fController.handleBreakpoint(breakpoint, true);
 			if (breakpoint instanceof AntLineBreakpoint) {
 				if (((AntLineBreakpoint) breakpoint).isRunToLine()) {
 					if (fRunToLineBreakpoints == null) {
 						fRunToLineBreakpoints = new ArrayList<>();
 					}
 					fRunToLineBreakpoints.add(breakpoint);
 				}
 			}
 		}
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.IBreakpointListener#breakpointRemoved(org.eclipse.debug.core.model.IBreakpoint,
 	 * org.eclipse.core.resources.IMarkerDelta)
 	 */
 	@Override
 	public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
 		if (!fTerminated) {
 			fController.handleBreakpoint(breakpoint, false);
 			if (fRunToLineBreakpoints != null) {
 				if (fRunToLineBreakpoints.remove(breakpoint) && fRunToLineBreakpoints.isEmpty()) {
 					fRunToLineBreakpoints = null;
 				}
 			}
 		}
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.IBreakpointListener#breakpointChanged(org.eclipse.debug.core.model.IBreakpoint,
 	 * org.eclipse.core.resources.IMarkerDelta)
 	 */
 	@Override
 	public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
 		if (supportsBreakpoint(breakpoint)) {
 			try {
 				if (breakpoint.isEnabled() && DebugPlugin.getDefault().getBreakpointManager().isEnabled()) {
 					breakpointAdded(breakpoint);
 				} else {
 					breakpointRemoved(breakpoint, null);
 				}
 			}
 			catch (CoreException e) {
 				// do nothing
 			}
 		}
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDisconnect#canDisconnect()
 	 */
 	@Override
 	public boolean canDisconnect() {
 		return false;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDisconnect#disconnect()
 	 */
 	@Override
 	public void disconnect() throws DebugException {
 		// do nothing
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IDisconnect#isDisconnected()
 	 */
 	@Override
 	public boolean isDisconnected() {
 		return false;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IMemoryBlockRetrieval#supportsStorageRetrieval()
 	 */
 	@Override
 	public boolean supportsStorageRetrieval() {
 		return false;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.model.IMemoryBlockRetrieval#getMemoryBlock(long, long)
 	 */
 	@Override
 	public IMemoryBlock getMemoryBlock(long startAddress, long length) throws DebugException {
 		return null;
 	}

 	/**
 	 * Notification we have connected to the Ant build logger and it has started. Resume the build.
 	 */
 	public void buildStarted() {
 		fireCreationEvent();
 		installDeferredBreakpoints();
 		try {
 			resume();
 		}
 		catch (DebugException e) {
 			// do nothing
 		}
 	}

 	/**
 	 * Install breakpoints that are already registered with the breakpoint manager if the breakpoint manager is enabled and the breakpoint is enabled.
 	 */
 	private void installDeferredBreakpoints() {
 		IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
 		if (!manager.isEnabled()) {
 			return;
 		}
 		IBreakpoint[] breakpoints = manager.getBreakpoints(IAntDebugConstants.ID_ANT_DEBUG_MODEL);
 		for (int i = 0; i < breakpoints.length; i++) {
 			IBreakpoint breakpoint = breakpoints[i];
 			try {
 				if (breakpoint.isEnabled()) {
 					breakpointAdded(breakpoints[i]);
 				}
 			}
 			catch (CoreException e) {
 				// do nothing
 			}
 		}
 	}

 	/**
 	 * Called when this debug target terminates.
 	 */
 	public synchronized void terminated() {
 		if (!fTerminated) {
 			fThreads = new IThread[0];
 			fTerminated = true;
 			fSuspended = false;
 			fController.terminate();
 			if (DebugPlugin.getDefault() != null) {
 				DebugPlugin.getDefault().getBreakpointManager().removeBreakpointListener(this);
 				DebugPlugin.getDefault().removeDebugEventListener(this);
 				DebugPlugin.getDefault().getBreakpointManager().removeBreakpointManagerListener(this);
 			}
 			if (!getProcess().isTerminated()) {
 				try {
 					fProcess.terminate();
 				}
 				catch (DebugException e) {
 					// do nothing
 				}
 			}
 			if (DebugPlugin.getDefault() != null) {
 				fireTerminateEvent();
 			}
 		}
 	}

 	/**
 	 * Single step the Ant build.
 	 */
 	public void stepOver() {
 		fSuspended = false;
 		fController.stepOver();
 		fireResumeEvent(DebugEvent.CLIENT_REQUEST);
 	}

 	/**
 	 * Step-into the Ant build.
 	 */
 	public void stepInto() {
 		fSuspended = false;
 		fController.stepInto();
 		fireResumeEvent(DebugEvent.CLIENT_REQUEST);
 	}

 	/**
 	 * Notification a breakpoint was encountered. Determine which breakpoint was hit and fire a suspend event.
 	 *
 	 * @param event
 	 *            debug event
 	 */
 	public void breakpointHit(String event) {
 		// determine which breakpoint was hit, and set the thread's breakpoint
 		String[] datum = event.split(DebugMessageIds.MESSAGE_DELIMITER);
 		String fileName = datum[1];
 		int lineNumber = Integer.parseInt(datum[2]);
 		IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(IAntDebugConstants.ID_ANT_DEBUG_MODEL);
 		boolean found = false;
 		for (int i = 0; i < breakpoints.length; i++) {
 			ILineBreakpoint lineBreakpoint = (ILineBreakpoint) breakpoints[i];
 			if (setThreadBreakpoint(lineBreakpoint, lineNumber, fileName)) {
 				found = true;
 				break;
 			}
 		}
 		if (!found && fRunToLineBreakpoints != null) {
 			Iterator<IBreakpoint> iter = fRunToLineBreakpoints.iterator();
 			while (iter.hasNext()) {
 				ILineBreakpoint lineBreakpoint = (ILineBreakpoint) iter.next();
 				if (setThreadBreakpoint(lineBreakpoint, lineNumber, fileName)) {
 					break;
 				}
 			}
 		}
 		suspended(DebugEvent.BREAKPOINT);
 	}

 	private boolean setThreadBreakpoint(ILineBreakpoint lineBreakpoint, int lineNumber, String fileName) {
 		try {
 			if (lineBreakpoint.getLineNumber() == lineNumber && fileName.equals(lineBreakpoint.getMarker().getResource().getLocation().toOSString())) {
 				fThread.setBreakpoints(new IBreakpoint[] { lineBreakpoint });
 				return true;
 			}
 		}
 		catch (CoreException e) {
 			// do nothing
 		}
 		return false;
 	}

 	public void breakpointHit(IBreakpoint breakpoint) {
 		fThread.setBreakpoints(new IBreakpoint[] { breakpoint });
 		suspended(DebugEvent.BREAKPOINT);
 	}

 	public void getStackFrames() {
 		if (isSuspended()) {
 			fController.getStackFrames();
 		}
 	}

 	public void getProperties() {
 		if (!fTerminated) {
 			fController.getProperties();
 		}
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.debug.core.IDebugEventSetListener#handleDebugEvents(org.eclipse.debug.core.DebugEvent[])
 	 */
 	@Override
 	public void handleDebugEvents(DebugEvent[] events) {
 		for (int i = 0; i < events.length; i++) {
 			DebugEvent event = events[i];
 			if (event.getKind() == DebugEvent.TERMINATE && event.getSource().equals(fProcess)) {
 				terminated();
 			}
 		}
 	}

 	/**
 	 * When the breakpoint manager disables, remove all registered breakpoints requests from the VM. When it enables, reinstall them.
 	 *
 	 * @see org.eclipse.debug.core.IBreakpointManagerListener#breakpointManagerEnablementChanged(boolean)
 	 */
 	@Override
 	public void breakpointManagerEnablementChanged(boolean enabled) {
 		IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(IAntDebugConstants.ID_ANT_DEBUG_MODEL);
 		for (int i = 0; i < breakpoints.length; i++) {
 			IBreakpoint breakpoint = breakpoints[i];
 			if (enabled) {
 				breakpointAdded(breakpoint);
 			} else {
 				breakpointRemoved(breakpoint, null);
 			}
 		}
 	}

 	public IAntDebugController getAntDebugController() {
 		return fController;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004, 2016 IBM Corporation and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.ant.internal.launching.debug.model;

	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;

	import org.eclipse.ant.internal.launching.debug.IAntDebugConstants;
	import org.eclipse.ant.internal.launching.debug.IAntDebugController;

	import org.eclipse.core.externaltools.internal.IExternalToolConstants;
	import org.eclipse.core.variables.VariablesPlugin;

	import org.eclipse.core.runtime.CoreException;

	import org.eclipse.core.resources.IMarkerDelta;

	import org.eclipse.debug.core.DebugEvent;
	import org.eclipse.debug.core.DebugException;
	import org.eclipse.debug.core.DebugPlugin;
	import org.eclipse.debug.core.IBreakpointManager;
	import org.eclipse.debug.core.IBreakpointManagerListener;
	import org.eclipse.debug.core.IDebugEventSetListener;
	import org.eclipse.debug.core.ILaunch;
	import org.eclipse.debug.core.model.IBreakpoint;
	import org.eclipse.debug.core.model.IDebugTarget;
	import org.eclipse.debug.core.model.ILineBreakpoint;
	import org.eclipse.debug.core.model.IMemoryBlock;
	import org.eclipse.debug.core.model.IProcess;
	import org.eclipse.debug.core.model.IThread;

	/**
	* Ant Debug Target
	*/
	public class AntDebugTarget extends AntDebugElement implements IDebugTarget, IDebugEventSetListener, IBreakpointManagerListener {

	// associated system process (Ant Build)
	private IProcess fProcess;

	// containing launch object
	private ILaunch fLaunch;

	// Build file name
	private String fName;

	// suspend state
	private boolean fSuspended = false;

	// terminated state
	private boolean fTerminated = false;

	// threads
	private AntThread fThread;
	private IThread[] fThreads;

	private IAntDebugController fController;

	private List<IBreakpoint> fRunToLineBreakpoints;

	/**
	* Constructs a new debug target in the given launch for the associated Ant build process.
	*
	* @param launch
	* containing launch
	* @param process
	* Ant build process
	* @param controller
	* the controller to communicate to the Ant build
	*/
	public AntDebugTarget(ILaunch launch, IProcess process, IAntDebugController controller) {
	super(null);
	fLaunch = launch;
	fProcess = process;

	fController = controller;

	fThread = new AntThread(this);
	fThreads = new IThread[] { fThread };

	DebugPlugin.getDefault().getBreakpointManager().addBreakpointManagerListener(this);
	DebugPlugin.getDefault().getBreakpointManager().addBreakpointListener(this);
	DebugPlugin.getDefault().addDebugEventListener(this);
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDebugTarget#getProcess()
	*/
	@Override
	public IProcess getProcess() {
	return fProcess;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDebugTarget#getThreads()
	*/
	@Override
	public IThread[] getThreads() {
	return fThreads;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDebugTarget#hasThreads()
	*/
	@Override
	public boolean hasThreads() throws DebugException {
	return !fTerminated && fThreads.length > 0;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDebugTarget#getName()
	*/
	@Override
	public String getName() throws DebugException {
	if (fName == null) {
	try {
	fName = getLaunch().getLaunchConfiguration().getAttribute(IExternalToolConstants.ATTR_LOCATION, DebugModelMessages.AntDebugTarget_0);
	fName = VariablesPlugin.getDefault().getStringVariableManager().performStringSubstitution(fName);
	}
	catch (CoreException e) {
	fName = DebugModelMessages.AntDebugTarget_0;
	}
	}
	return fName;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDebugTarget#supportsBreakpoint(org.eclipse.debug.core.model.IBreakpoint)
	*/
	@Override
	public boolean supportsBreakpoint(IBreakpoint breakpoint) {
	if (breakpoint.getModelIdentifier().equals(IAntDebugConstants.ID_ANT_DEBUG_MODEL)) {
	// need to consider all breakpoints as no way to tell which set
	// of build files will be executed (ant task)
	return true;
	}
	return false;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDebugElement#getDebugTarget()
	*/
	@Override
	public IDebugTarget getDebugTarget() {
	return this;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDebugElement#getLaunch()
	*/
	@Override
	public ILaunch getLaunch() {
	return fLaunch;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.ITerminate#canTerminate()
	*/
	@Override
	public boolean canTerminate() {
	return !fTerminated;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.ITerminate#isTerminated()
	*/
	@Override
	public boolean isTerminated() {
	return fTerminated;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.ITerminate#terminate()
	*/
	@Override
	public void terminate() throws DebugException {
	terminated();
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.ISuspendResume#canResume()
	*/
	@Override
	public boolean canResume() {
	return !fTerminated && fSuspended;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.ISuspendResume#canSuspend()
	*/
	@Override
	public boolean canSuspend() {
	return !fTerminated && !fSuspended;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.ISuspendResume#isSuspended()
	*/
	@Override
	public boolean isSuspended() {
	return fSuspended;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.ISuspendResume#resume()
	*/
	@Override
	public void resume() throws DebugException {
	fSuspended = false;
	fController.resume();
	if (fThread.isSuspended()) {
	fThread.resumedByTarget();
	}
	fireResumeEvent(DebugEvent.CLIENT_REQUEST);
	}

	/**
	* Notification the target has suspended for the given reason
	*
	* @param detail
	* reason for the suspend
	*/
	public void suspended(int detail) {
	fSuspended = true;
	fThread.setStepping(false);
	fThread.fireSuspendEvent(detail);
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.ISuspendResume#suspend()
	*/
	@Override
	public void suspend() throws DebugException {
	fController.suspend();
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.IBreakpointListener#breakpointAdded(org.eclipse.debug.core.model.IBreakpoint)
	*/
	@Override
	public void breakpointAdded(IBreakpoint breakpoint) {
	if (!fTerminated) {
	fController.handleBreakpoint(breakpoint, true);
	if (breakpoint instanceof AntLineBreakpoint) {
	if (((AntLineBreakpoint) breakpoint).isRunToLine()) {
	if (fRunToLineBreakpoints == null) {
	fRunToLineBreakpoints = new ArrayList<>();
	}
	fRunToLineBreakpoints.add(breakpoint);
	}
	}
	}
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.IBreakpointListener#breakpointRemoved(org.eclipse.debug.core.model.IBreakpoint,
	* org.eclipse.core.resources.IMarkerDelta)
	*/
	@Override
	public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
	if (!fTerminated) {
	fController.handleBreakpoint(breakpoint, false);
	if (fRunToLineBreakpoints != null) {
	if (fRunToLineBreakpoints.remove(breakpoint) && fRunToLineBreakpoints.isEmpty()) {
	fRunToLineBreakpoints = null;
	}
	}
	}
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.IBreakpointListener#breakpointChanged(org.eclipse.debug.core.model.IBreakpoint,
	* org.eclipse.core.resources.IMarkerDelta)
	*/
	@Override
	public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
	if (supportsBreakpoint(breakpoint)) {
	try {
	if (breakpoint.isEnabled() && DebugPlugin.getDefault().getBreakpointManager().isEnabled()) {
	breakpointAdded(breakpoint);
	} else {
	breakpointRemoved(breakpoint, null);
	}
	}
	catch (CoreException e) {
	// do nothing
	}
	}
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDisconnect#canDisconnect()
	*/
	@Override
	public boolean canDisconnect() {
	return false;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDisconnect#disconnect()
	*/
	@Override
	public void disconnect() throws DebugException {
	// do nothing
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IDisconnect#isDisconnected()
	*/
	@Override
	public boolean isDisconnected() {
	return false;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IMemoryBlockRetrieval#supportsStorageRetrieval()
	*/
	@Override
	public boolean supportsStorageRetrieval() {
	return false;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.model.IMemoryBlockRetrieval#getMemoryBlock(long, long)
	*/
	@Override
	public IMemoryBlock getMemoryBlock(long startAddress, long length) throws DebugException {
	return null;
	}

	/**
	* Notification we have connected to the Ant build logger and it has started. Resume the build.
	*/
	public void buildStarted() {
	fireCreationEvent();
	installDeferredBreakpoints();
	try {
	resume();
	}
	catch (DebugException e) {
	// do nothing
	}
	}

	/**
	* Install breakpoints that are already registered with the breakpoint manager if the breakpoint manager is enabled and the breakpoint is enabled.
	*/
	private void installDeferredBreakpoints() {
	IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
	if (!manager.isEnabled()) {
	return;
	}
	IBreakpoint[] breakpoints = manager.getBreakpoints(IAntDebugConstants.ID_ANT_DEBUG_MODEL);
	for (int i = 0; i < breakpoints.length; i++) {
	IBreakpoint breakpoint = breakpoints[i];
	try {
	if (breakpoint.isEnabled()) {
	breakpointAdded(breakpoints[i]);
	}
	}
	catch (CoreException e) {
	// do nothing
	}
	}
	}

	/**
	* Called when this debug target terminates.
	*/
	public synchronized void terminated() {
	if (!fTerminated) {
	fThreads = new IThread[0];
	fTerminated = true;
	fSuspended = false;
	fController.terminate();
	if (DebugPlugin.getDefault() != null) {
	DebugPlugin.getDefault().getBreakpointManager().removeBreakpointListener(this);
	DebugPlugin.getDefault().removeDebugEventListener(this);
	DebugPlugin.getDefault().getBreakpointManager().removeBreakpointManagerListener(this);
	}
	if (!getProcess().isTerminated()) {
	try {
	fProcess.terminate();
	}
	catch (DebugException e) {
	// do nothing
	}
	}
	if (DebugPlugin.getDefault() != null) {
	fireTerminateEvent();
	}
	}
	}

	/**
	* Single step the Ant build.
	*/
	public void stepOver() {
	fSuspended = false;
	fController.stepOver();
	fireResumeEvent(DebugEvent.CLIENT_REQUEST);
	}

	/**
	* Step-into the Ant build.
	*/
	public void stepInto() {
	fSuspended = false;
	fController.stepInto();
	fireResumeEvent(DebugEvent.CLIENT_REQUEST);
	}

	/**
	* Notification a breakpoint was encountered. Determine which breakpoint was hit and fire a suspend event.
	*
	* @param event
	* debug event
	*/
	public void breakpointHit(String event) {
	// determine which breakpoint was hit, and set the thread's breakpoint
	String[] datum = event.split(DebugMessageIds.MESSAGE_DELIMITER);
	String fileName = datum[1];
	int lineNumber = Integer.parseInt(datum[2]);
	IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(IAntDebugConstants.ID_ANT_DEBUG_MODEL);
	boolean found = false;
	for (int i = 0; i < breakpoints.length; i++) {
	ILineBreakpoint lineBreakpoint = (ILineBreakpoint) breakpoints[i];
	if (setThreadBreakpoint(lineBreakpoint, lineNumber, fileName)) {
	found = true;
	break;
	}
	}
	if (!found && fRunToLineBreakpoints != null) {
	Iterator<IBreakpoint> iter = fRunToLineBreakpoints.iterator();
	while (iter.hasNext()) {
	ILineBreakpoint lineBreakpoint = (ILineBreakpoint) iter.next();
	if (setThreadBreakpoint(lineBreakpoint, lineNumber, fileName)) {
	break;
	}
	}
	}
	suspended(DebugEvent.BREAKPOINT);
	}

	private boolean setThreadBreakpoint(ILineBreakpoint lineBreakpoint, int lineNumber, String fileName) {
	try {
	if (lineBreakpoint.getLineNumber() == lineNumber && fileName.equals(lineBreakpoint.getMarker().getResource().getLocation().toOSString())) {
	fThread.setBreakpoints(new IBreakpoint[] { lineBreakpoint });
	return true;
	}
	}
	catch (CoreException e) {
	// do nothing
	}
	return false;
	}

	public void breakpointHit(IBreakpoint breakpoint) {
	fThread.setBreakpoints(new IBreakpoint[] { breakpoint });
	suspended(DebugEvent.BREAKPOINT);
	}

	public void getStackFrames() {
	if (isSuspended()) {
	fController.getStackFrames();
	}
	}

	public void getProperties() {
	if (!fTerminated) {
	fController.getProperties();
	}
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.debug.core.IDebugEventSetListener#handleDebugEvents(org.eclipse.debug.core.DebugEvent[])
	*/
	@Override
	public void handleDebugEvents(DebugEvent[] events) {
	for (int i = 0; i < events.length; i++) {
	DebugEvent event = events[i];
	if (event.getKind() == DebugEvent.TERMINATE && event.getSource().equals(fProcess)) {
	terminated();
	}
	}
	}

	/**
	* When the breakpoint manager disables, remove all registered breakpoints requests from the VM. When it enables, reinstall them.
	*
	* @see org.eclipse.debug.core.IBreakpointManagerListener#breakpointManagerEnablementChanged(boolean)
	*/
	@Override
	public void breakpointManagerEnablementChanged(boolean enabled) {
	IBreakpoint[] breakpoints = DebugPlugin.getDefault().getBreakpointManager().getBreakpoints(IAntDebugConstants.ID_ANT_DEBUG_MODEL);
	for (int i = 0; i < breakpoints.length; i++) {
	IBreakpoint breakpoint = breakpoints[i];
	if (enabled) {
	breakpointAdded(breakpoint);
	} else {
	breakpointRemoved(breakpoint, null);
	}
	}
	}

	public IAntDebugController getAntDebugController() {
	return fController;
	}
	}