Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDarin Wright2001-05-18 10:25:56 +0000
committerDarin Wright2001-05-18 10:25:56 +0000
commit3e4fc4400f54e51207e1b92bdc1232e6e68d5e88 (patch)
tree3a47ad5727e750d31a2d475c6abb70e016394dfb /org.eclipse.debug.core
downloadeclipse.platform.debug-3e4fc4400f54e51207e1b92bdc1232e6e68d5e88.tar.gz
eclipse.platform.debug-3e4fc4400f54e51207e1b92bdc1232e6e68d5e88.tar.xz
eclipse.platform.debug-3e4fc4400f54e51207e1b92bdc1232e6e68d5e88.zip
*** empty log message ***
Diffstat (limited to 'org.eclipse.debug.core')
-rw-r--r--org.eclipse.debug.core/.classpath9
-rw-r--r--org.eclipse.debug.core/.cvsignore1
-rw-r--r--org.eclipse.debug.core/.options1
-rw-r--r--org.eclipse.debug.core/.vcm_meta6
-rw-r--r--org.eclipse.debug.core/build.properties2
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/DebugEvent.java204
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/DebugException.java39
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java226
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointListener.java62
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManager.java253
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugConstants.java66
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugEventListener.java30
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugStatusConstants.java61
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunch.java79
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchListener.java36
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchManager.java151
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/ILauncher.java96
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/IStreamListener.java34
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/Launch.java259
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IBreakpointSupport.java87
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDebugElement.java175
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDebugTarget.java52
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDisconnect.java51
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/ILauncherDelegate.java109
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IProcess.java75
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/ISourceLocator.java68
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStackFrame.java60
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStep.java91
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStreamMonitor.java49
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStreamsProxy.java58
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/ISuspendResume.java64
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/ITerminate.java47
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IThread.java57
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IValue.java100
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IValueModification.java55
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/IVariable.java78
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/model/package.html57
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/package.html176
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/BreakpointManager.java487
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugCoreResources.properties55
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugCoreUtils.java58
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/InputStreamMonitor.java160
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/LaunchManager.java241
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/Launcher.java113
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/ListenerList.java142
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/ProcessMonitor.java72
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/RuntimeProcess.java202
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/internal/core/StreamsProxy.java86
-rw-r--r--org.eclipse.debug.core/doc/hglegal.htm19
-rw-r--r--org.eclipse.debug.core/doc/ngibmcpy.gifbin0 -> 1542 bytes
-rw-r--r--org.eclipse.debug.core/doc/org_eclipse_debug_core.html36
-rw-r--r--org.eclipse.debug.core/doc/org_eclipse_debug_core_launchers.html95
-rw-r--r--org.eclipse.debug.core/exportplugin.xml28
-rw-r--r--org.eclipse.debug.core/plugin.jars1
-rw-r--r--org.eclipse.debug.core/plugin.xml37
55 files changed, 4956 insertions, 0 deletions
diff --git a/org.eclipse.debug.core/.classpath b/org.eclipse.debug.core/.classpath
new file mode 100644
index 000000000..13b851a2c
--- /dev/null
+++ b/org.eclipse.debug.core/.classpath
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="lib" path="C:\eclipse\jre\lib\rt.jar"/>
+ <classpathentry kind="src" path="Eclipse Debug Core"/>
+ <classpathentry kind="lib" path="C:\eclipse\plugins\org.apache.xerces\xerces.jar"/>
+ <classpathentry kind="lib" path="C:\eclipse\plugins\org.eclipse.core.resources\resources.jar"/>
+ <classpathentry kind="lib" path="C:\eclipse\plugins\org.eclipse.core.runtime\runtime.jar"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/org.eclipse.debug.core/.cvsignore b/org.eclipse.debug.core/.cvsignore
new file mode 100644
index 000000000..c5e82d745
--- /dev/null
+++ b/org.eclipse.debug.core/.cvsignore
@@ -0,0 +1 @@
+bin \ No newline at end of file
diff --git a/org.eclipse.debug.core/.options b/org.eclipse.debug.core/.options
new file mode 100644
index 000000000..a3e35f6ef
--- /dev/null
+++ b/org.eclipse.debug.core/.options
@@ -0,0 +1 @@
+org.eclipse.debug.core/debug=true \ No newline at end of file
diff --git a/org.eclipse.debug.core/.vcm_meta b/org.eclipse.debug.core/.vcm_meta
new file mode 100644
index 000000000..aae2e1b3e
--- /dev/null
+++ b/org.eclipse.debug.core/.vcm_meta
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project-description>
+ <nature id="org.eclipse.jdt.core.javanature"/>
+ <builder name="org.eclipse.jdt.core.javabuilder">
+ </builder>
+</project-description>
diff --git a/org.eclipse.debug.core/build.properties b/org.eclipse.debug.core/build.properties
new file mode 100644
index 000000000..69173dbf3
--- /dev/null
+++ b/org.eclipse.debug.core/build.properties
@@ -0,0 +1,2 @@
+build.includes=.options,plugin.jars,plugin.xml
+build.vaj.Eclipse\ Debug\ Core=Eclipse Debug Core \ No newline at end of file
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugEvent.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugEvent.java
new file mode 100644
index 000000000..33fdcb1ad
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugEvent.java
@@ -0,0 +1,204 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import java.util.EventObject;
+
+/**
+ * A debug event describes an event in a program being debugged.
+ * Debug model implementations are required to generate debug events as
+ * specified by this class. Debug events also describe the creation and
+ * termiation of system processes.
+ * <p>
+ * The following list defines the events that are required to
+ * be generated for each element type, and when the event should be created.
+ * The object that an event is associated
+ * with is available from the event's <code>getSource</code> method. Creation
+ * events are guaranteed to occur in a top down order - that is, parents are created
+ * before children. Termination events are guaranteed to occur in a bottom up order -
+ * that is, children before parents. However, termination events are not guaranteed
+ * for all elements that are created. That is, terminate events can be coalesced - a
+ * terminate event for a parent signals that all children have been terminated.
+ * </p>
+ * <p>
+ * The generic <code>CHANGE</code> event can be fired at any time by any element.
+ * Generally, a client of a debug model, such as as a UI, can get sufficient
+ * information to update by listening/responding to the other event kinds. However,
+ * if a debug model needs to inform clients of a change that is not specified
+ * by create/terminate/suspend/resume, the <code>CHANGE</code> event may be used.
+ * For example, generally, the only way a thread or any of its children can change
+ * state between a suspend and resume operation, is if the thread or owning debug
+ * target is termianted. However, if a debug model supports some other operation
+ * that would allow a debug element to change state while suspended, the debug model
+ * would fire a change event for that element.
+ * </p>
+ * <ul>
+ * <li><code>IDebugTarget</code>
+ * <ul>
+ * <li><code>CREATE</code> - a debug target has been created and is ready
+ * to begin a debug session.</li>
+ * <li><code>TERMINATE</code> - a debug target has terminated and the debug
+ * session has ended.</li>
+ * </ul>
+ * </li>
+ * <li><code>IThread</code>
+ * <ul>
+ * <li><code>CREATE</code> - a thread has been created in a debug target.</li>
+ * <li><code>TERMINATE</code> - a thread has ended.</li>
+ * <li><code>SUSPEND</code> - a thread has suspended. Event detail provides
+ * the reason for the suspension, or -1 if unknown:<ul>
+ * <li>STEP_END - a request to step has completed</li>
+ * <li>BREAKPOINT - a breakpoint has been hit</li>
+ * <li>CLIENT_REQUEST - a user request has caused the thread to suspend</li>
+ * </ul>
+ * </li>
+ * <li><code>RESUME</code> - a thread has resumed. Event detail provides
+ * the reason for the resume, or -1 if unknown:<ul>
+ * <li>STEP_START - a thread is being resumed because of a request to step</li>
+ * <li>CLIENT_REQUEST - a thread is being resumed</li>
+ * </ul>
+ * </li>
+ * </ul>
+ * </li>
+ * <li><code>IStackFrame</code> - no events are specified for stack frames.
+ * When a thread is suspended, it has children (stack frames). When a thread resumes,
+ * stack frames are unavailable.
+ * </li>
+ * <li><code>IVariable</code> - no events are specified for variables.
+ * When a thread is suspended, stack frames have variables. When a thread resumes,
+ * variables are unavailable.
+ * </li>
+ * <li><code>IValue</code> - no events are specified for values.
+ * </li>
+ * <li><code>IProcess</code>
+ * <ul>
+ * <li><code>CREATE</code> - a system process has been created.</li>
+ * <li><code>TERMINATE</code> - a system process has terminated.</li>
+ * </ul>
+ * </li>
+ * </ul>
+ * <p>
+ * Clients may instantiate this class. Clients are not intended to subclass this class.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ */
+public final class DebugEvent extends EventObject {
+
+ /**
+ * Resume event.
+ */
+ public static final int RESUME= 0x0001;
+
+ /**
+ * Suspend event.
+ */
+ public static final int SUSPEND= 0x0002;
+
+ /**
+ * Create event.
+ */
+ public static final int CREATE= 0x0004;
+
+ /**
+ * Terminate event.
+ */
+ public static final int TERMINATE= 0x0008;
+
+ /**
+ * Change event.
+ */
+ public static final int CHANGE= 0x0010;
+
+ /**
+ * Step start detail. Indicates a thread was resumed by a step action.
+ */
+ public static final int STEP_START= 0x0001;
+
+ /**
+ * Step end detail. Indicates a thread was suspended due
+ * to the completion of a step action.
+ */
+ public static final int STEP_END= 0x0002;
+
+ /**
+ * Breakpoint detail. Indicates a thread was suspended by
+ * a breakpoint.
+ */
+ public static final int BREAKPOINT= 0x0004;
+
+ /**
+ * Client request detail. Indicates a thread was suspended due
+ * to a client request.
+ */
+ public static final int CLIENT_REQUEST= 0x0008;
+
+ /**
+ * The kind of event - one of the kind constants defined by
+ * this class.
+ */
+ private int fKind= 0;
+
+ /**
+ * The detail of the event - one of the detail constants defined by
+ * this class.
+ */
+ private int fDetail= -1;
+ /**
+ * Constructs a new debug event of the given kind with a detail code of -1.
+ *
+ * @param eventSource the object that generated the event
+ * @param kind the kind of debug envent (one of the
+ * constants in <code>IDebugEventConstants</code>)
+ */
+ public DebugEvent(Object eventSource, int kind) {
+ this(eventSource, kind, -1);
+ }
+
+ /**
+ * Constructs a new debug event of the given kind with the given detail.
+ *
+ * @param eventSource the object that generated the event
+ * @param kind the kind of debug envent (one of the
+ * kine constants defined by this class)
+ * @param detail extra information about the event (one of the
+ * detail constants defined by this class), or -1 if
+ * unspecified
+ */
+ public DebugEvent(Object eventSource, int kind, int detail) {
+ super(eventSource);
+ if ((kind & (RESUME | SUSPEND | CREATE | TERMINATE | CHANGE)) == 0)
+ throw new IllegalArgumentException("kind is not one of the allowed constants, see IDebugEventConstants");
+ if (detail != -1 && (detail & (STEP_END | STEP_START | BREAKPOINT | CLIENT_REQUEST)) == 0)
+ throw new IllegalArgumentException("detail is not one of the allowed constants, see IDebugEventConstants");
+ fKind= kind;
+ fDetail= detail;
+ }
+
+ /**
+ * Returns a constant describing extra detail about the event - one
+ * of the detail constants defined by this class, or -1 if unspecified.
+ *
+ * @return the detail code
+ */
+ public int getDetail() {
+ return fDetail;
+ }
+
+ /**
+ * Returns this event's kind - one of the kind constants defined by this class.
+ */
+ public int getKind() {
+ return fKind;
+ }
+
+}
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugException.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugException.java
new file mode 100644
index 000000000..0480f26bc
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugException.java
@@ -0,0 +1,39 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+
+
+/**
+ * A checked exception representing a failure.
+ * <p>
+ * Clients may instantiate this class. Clients are not intended to subclass this class.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IStatus
+ */
+public class DebugException extends CoreException {
+
+ /**
+ * Constructs a new debug exception with the given status object.
+ *
+ * @param status the status object to be associated with this exception
+ * @see IStatus
+ */
+ public DebugException(IStatus status) {
+ super(status);
+ }
+
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java
new file mode 100644
index 000000000..8b38fe6bc
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java
@@ -0,0 +1,226 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2001
+ */
+
+import org.eclipse.debug.core.model.IProcess;
+import org.eclipse.debug.internal.core.*;
+import org.eclipse.core.runtime.*;
+
+/**
+ * There is one instance of the debug plugin available from
+ * <code>DebugPlugin.getDefault()</code>. The debug plugin provides:
+ * <ul>
+ * <li>access to the breakpoint manager</li>
+ * <li>access to the launch manager</li>
+ * <li>access to the registered launcher extensions</li>
+ * <li>registration for debug events</li>
+ * <li>notification of debug events</li>
+ * </ul>
+ * <p>
+ * Clients may not instantiate or subclass this class.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ */
+public class DebugPlugin extends Plugin {
+
+ /**
+ * The singleton debug plug-in instance.
+ */
+ private static DebugPlugin fgDebugPlugin= null;
+
+ /**
+ * The collection of launcher extensions.
+ */
+ private Launcher[] fLaunchers= new Launcher[0];
+
+ /**
+ * The singleton breakpoint manager.
+ */
+ private BreakpointManager fBreakpointManager;
+
+ /**
+ * The singleton launch manager.
+ */
+ private LaunchManager fLaunchManager;
+
+ /**
+ * The collection of debug event listeners.
+ */
+ private ListenerList fEventListeners= new ListenerList(20);
+
+ /**
+ * Internal state...<code>true</code> if this plugin is in the
+ * process of shutting down.
+ */
+ private boolean fShuttingDown= false;
+
+ /**
+ * Returns the singleton instance of the debug plug-in.
+ */
+ public static DebugPlugin getDefault() {
+ return fgDebugPlugin;
+ }
+
+ /**
+ * Constructs the debug plug-in.
+ * <p>
+ * An instance of this plug-in runtime class is automatically created
+ * when the facilities provided by the Resources plug-in are required.
+ * <b>Clients must never explicitly instantiate a plug-in runtime class.</b>
+ * </p>
+ *
+ * @param pluginDescriptor the plug-in descriptor for the
+ * debug plug-in
+ */
+ public DebugPlugin(IPluginDescriptor descriptor) {
+ super(descriptor);
+ fgDebugPlugin= this;
+ }
+
+ /**
+ * Adds the given listener to the collection of registered debug
+ * event listeners. Has no effect if an identical listener is already
+ * registered.
+ *
+ * @param listener the listener to add
+ */
+ public void addDebugEventListener(IDebugEventListener listener) {
+ fEventListeners.add(listener);
+ }
+
+ /**
+ * Notifies all registered debug event listeners of the given event.
+ *
+ * @param event the debug event to fire
+ */
+ public void fireDebugEvent(DebugEvent event) {
+ if (fShuttingDown || event == null)
+ return;
+
+ Object[] listeners= fEventListeners.getListeners();
+ for (int i= 0; i < listeners.length; i++) {
+ ((IDebugEventListener) listeners[i]).handleDebugEvent(event);
+ }
+ }
+
+ /**
+ * Returns the breakpoint manager.
+ *
+ * @return the breakpoint manager
+ * @see IBreakpointManager
+ */
+ public IBreakpointManager getBreakpointManager() {
+ return fBreakpointManager;
+ }
+
+ /**
+ * Returns a collection of launcher extensions. Launchers represent
+ * and provide access to launcher extensions, delaying instantiation of
+ * the underlying launcher delegates until required.
+ *
+ * @return an array of launchers
+ * @see org.eclipse.debug.core.model.ILauncherDelegate
+ */
+ public ILauncher[] getLaunchers() {
+ return fLaunchers;
+ }
+
+ /**
+ * Returns the launch manager.
+ *
+ * @return the launch manager
+ * @see ILaunchManager
+ */
+ public ILaunchManager getLaunchManager() {
+ return fLaunchManager;
+ }
+
+ /**
+ * Loads all launcher extensions.
+ *
+ * @exception CoreException if creation of a launcher extension fails
+ */
+ protected void loadLaunchers() throws CoreException {
+ IPluginDescriptor descriptor= getDescriptor();
+ IExtensionPoint extensionPoint= descriptor.getExtensionPoint(IDebugConstants.EXTENSION_POINT_LAUNCHER);
+ IConfigurationElement[] infos= extensionPoint.getConfigurationElements();
+ fLaunchers= new Launcher[infos.length];
+ for (int i= 0; i < infos.length; i++) {
+ fLaunchers[i]= new Launcher(infos[i]);
+ }
+ }
+
+ /**
+ * Removes the given listener from the collection of registered debug
+ * event listeners. Has no effect if an identical listener is not already
+ * registered.
+ *
+ * @param listener the listener to remove
+ */
+ public void removeDebugEventListener(IDebugEventListener listener) {
+ fEventListeners.remove(listener);
+ }
+
+ /**
+ * Shuts down this debug plug-in and discards all plug-in state.
+ * <p>
+ * This method will be automatically invoked by the platform when
+ * the platform is shut down.
+ * </p>
+ * <b>Clients must never explicitly call this method.</b>
+ *
+ * @exception CoreException if this plug-in fails to shut down
+ */
+ public void shutdown() throws CoreException {
+ fShuttingDown= true;
+ super.shutdown();
+ fLaunchManager.shutdown();
+ fBreakpointManager.shutdown();
+ fgDebugPlugin= null;
+ }
+
+ /**
+ * Starts up the debug plug-in. This involves creating the launch and
+ * breakpoint managers, creating proxies to all launcher extensions,
+ * and restoring all persisted breakpoints.
+ * <p>
+ * This method is automatically invoked by the platform
+ * the first time any code in this plug-in is executed.
+ * </p>
+ * <b>Clients must never explicitly call this method.</b>
+ *
+ * @see Plugin#startup
+ * @exception CoreException if this plug-in fails to start up
+ */
+ public void startup() throws CoreException {
+ fLaunchManager= new LaunchManager();
+ fBreakpointManager= new BreakpointManager();
+ loadLaunchers();
+ fBreakpointManager.startup();
+ }
+
+ /**
+ * Creates and returns a new process representing the given
+ * <code>java.lang.Process</code>. A streams proxy is created
+ * for the I/O streams in the system process.
+ *
+ * @param process the system process to wrap
+ * @param label the label assigned to the process
+ * @return the process
+ * @see IProcess
+ */
+ public static IProcess newProcess(Process process, String label) {
+ return new RuntimeProcess(process, label);
+ }
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointListener.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointListener.java
new file mode 100644
index 000000000..10c8009e9
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointListener.java
@@ -0,0 +1,62 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2001
+ */
+
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IMarkerDelta;
+
+/**
+ * A breakpoint listener is notified of breakpoint additions,
+ * removals, and changes. Listeners register and deregister with the
+ * breakpoint manager.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IBreakpointManager
+ */
+
+public interface IBreakpointListener {
+
+ /**
+ * Notifies this listener that the given breakpoint has been added.
+ *
+ * @param breakpoint the added breakpoint
+ */
+ public void breakpointAdded(IMarker breakpoint);
+ /**
+ * Notifies this listener that the given breakpoint has been removed.
+ * If the given marker has been removed because it has been deleted,
+ * the associated marker delta is also provided such that any attributes
+ * of the marker can still be accessed.
+ *
+ * @param breakpoint the removed breakpoint
+ * @param delta the associated marker delta, or <code>null</code> when
+ * the breakpoint is removed from the breakpoint manager without
+ * being deleted
+ *
+ * @see org.eclipse.core.resources.IMarkerDelta
+ */
+ public void breakpointRemoved(IMarker breakpoint, IMarkerDelta delta);
+
+ /**
+ * Notifies this listener that an attribute of the given breakpoint has
+ * changed, as described by the delta.
+ *
+ * @param breakpoint the changed breakpoint
+ * @param delta the marker delta that describes the change
+ *
+ * @see org.eclipse.core.resources.IMarkerDelta
+ */
+ public void breakpointChanged(IMarker breakpoint, IMarkerDelta delta);
+
+} \ No newline at end of file
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManager.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManager.java
new file mode 100644
index 000000000..89a2ed266
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IBreakpointManager.java
@@ -0,0 +1,253 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.runtime.CoreException;
+
+/**
+ * The breakpoint manager manages the collection of breakpoints
+ * in the workspace. A breakpoint suspends the execution of a
+ * program being debugged. The kinds of breakpoint supported by each
+ * debug architecture and the information required to create those
+ * breakpoints is dictated by each debug architecture.
+ * <p>
+ * Breakpoints are implemented by markers. The debug plug-in defines a root
+ * breakpoint marker of which all breakpoints should be subtypes. The
+ * debug plug-in also defines a common line breakpoint. Convenience methods
+ * are defined to configure the attributes of breakpoints defined by
+ * the debug plug-in. See <code>configureBreakpoint(IMarker, String, boolean)</code>
+ * and <code>configureLineBreakpoint(IMarker, String, boolean, int, int, int)</code>.
+ * </p>
+ * <p>All breakpoints have:<ul>
+ * <li> a model identifier, specifying the identifier of the debug model the breakpoint
+ * is intended for</li>
+ * <li> a enabled attribute, specifying if the breakpoint is enabled or disabled</li>.
+ * </ul>
+ * Additionally, all line breakpoints have a line number and/or a character start and
+ * end range.
+ * </p>
+ * <p>
+ * Breakpoint creation is a client responsibility. Creation of a breakpoint requires
+ * the creation of a marker. It is a client responsibility to determine which
+ * resource a breakpoint marker should be associated/persisted with. Breakpoints
+ * are only considered active when registered with the breakpoint manager.
+ * </p>
+ * <p>
+ * As launches are registered and deregistered, the breakpoint
+ * manager automatically adds and removes debug targets associated with those
+ * lauches, as breakpoint listeners.
+ * Debug targets (implementors of <code>IBreakpointSupport</code>) are
+ * informed of breakpoint additions, removals, and changes if they
+ * respond <code>true</code> to <code>supportsBreakpoints()</code>.
+ * A debug target is responsible for installing all existing
+ * (applicable) breakpoints when created.
+ * </p>
+ * <p>
+ * This interface is not intended to be implemented by clients.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IMarker
+ * @see org.eclipse.debug.core.model.IBreakpointSupport
+ */
+public interface IBreakpointManager {
+
+ /**
+ * Configures the given breakpoint's <code>MODEL_IDENTIFIER</code>
+ * and <code>ENABLED</code> attributes to the given values.
+ * This is a convenience method for
+ * <code>IMarker.setAttribute(String, String)</code> and
+ * <code>IMarker.setAttribute(String, boolean)</code>.
+ *
+ * @param breakpoint the breakpoint marker to configure
+ * @param modelIdentifier the identifier of the debug model plug-in
+ * the breakpoint is associated with
+ * @param enabled the initial value of the enabled attribute of the
+ * breakpoint marker
+ *
+ * @exception CoreException if setting an attribute fails
+ * @see IMarker#setAttribute(String, String)
+ * @see IMarker#setAttribute(String, boolean)
+ */
+ void configureBreakpoint(IMarker breakpoint, String modelIdentifier, boolean enabled) throws CoreException;
+
+ /**
+ * Configures the given breakpoint's <code>MODEL_IDENTIFIER</code>,
+ * <code>ENABLED</code>, <code>LINE_NUMBER</code>, <code>CHAR_START</code>,
+ * and <code>CHAR_END</code> attributes to the given values.
+ * This is a convenience method for
+ * <code>IMarker.setAttribute(String, String)</code>,
+ * <code>IMarker.setAttribute(String, boolean)</code>, and
+ * <code>IMarker.setAttribute(String, int)</code>.
+ *
+ * @param breakpoint the line breakpoint marker to configure
+ * @param modelIdentifier the identifier of the debug model plug-in
+ * the breakpoint is associated with
+ * @param enabled the initial value of the enabled attribute of the
+ * breakpoint marker
+ * @param lineNumber the line number the breakpoint is associated with, or -1
+ * if unknown
+ * @param charStart the index in an associated source element, of the first
+ * character associated with the breakoint, or -1 if unknown
+ * @param charEnd the index in an associated source element, of the last
+ * character associated with the breakoint, or -1 if unknown
+ *
+ * @exception CoreException if setting an attribute fails
+ * @see IMarker#setAttribute(String, String)
+ * @see IMarker#setAttribute(String, boolean)
+ * @see IMarker#setAttribute(String, int)
+ */
+ void configureLineBreakpoint(IMarker breakpoint, String modelIdentifier, boolean enabled, int lineNumber, int charStart, int charEnd) throws CoreException;
+
+ /**
+ * Adds the given breakpoint to the collection of active breakpoints
+ * in the workspace and notifies all registered listeners. This has no effect
+ * if the given breakpoint is already registered.
+ *
+ * @param breakpoint the breakpoint to add
+ *
+ * @exception DebugException if adding fails. Reasons include:<ul>
+ * <li>CONFIGURATION_INVALID - the required <code>MODEL_IDENTIFIER</code> attribute
+ * is not set on the breakpoint marker.</li>
+ * <li>A <code>CoreException</code> occurred while verifying the <code>MODEL_IDENTIFIER</code>
+ * attribute.</li>
+ * </ul>
+ */
+ void addBreakpoint(IMarker breakpoint) throws DebugException;
+
+ /**
+ * Returns a collection of all existing breakpoints.
+ * Returns an empty array if no breakpoints exist.
+ *
+ * @return an array of breakpoint markers
+ */
+ IMarker[] getBreakpoints();
+
+ /**
+ * Returns a collection of all breakpoints registered for the
+ * given debug model. Answers an empty array if no breakpoints are registered
+ * for the given debug model.
+ *
+ * @param modelIdentifier identifier of a debug model plug-in
+ * @return an array of breakpoint markers
+ */
+ IMarker[] getBreakpoints(String modelIdentifier);
+
+ /**
+ * Returns the value of the <code>ENABLED</code> attribute of the
+ * given breakpoint - <code>true</code> if the breakpoint is enabled,
+ * otherwise <code>false</code>. By default, if the attribute has not
+ * been set, a breakpoint is considered enabled.
+ * Note, this method returns <code>false</code>
+ * if an exception occurs while accessing the attribute. This is
+ * a convenience method for
+ * <code>IMarker.getAttribute(String, boolean)</code>.
+ *
+ * @param breakpoint the breakpoint
+ * @return whether the breakpoint is enabled
+ * @see IMarker#getAttribute(String, boolean)
+ */
+ boolean isEnabled(IMarker breakpoint);
+
+ /**
+ * Sets the value of the <code>ENABLED</code> attribute of the
+ * given breakpoint. This is a convenience method for
+ * <code>IMarker.setAttribute(String, boolean)</code>.
+ *
+ * @exception CoreException if setting the attribute fails
+ * @see IMarker#setAttribute(String, boolean)
+ */
+ void setEnabled(IMarker breakpoint, boolean value) throws CoreException;
+
+ /**
+ * Returns whether the given breakpoint is currently
+ * registered with this breakpoint manager.
+ *
+ * @return whether the breakpoint is registered
+ */
+ boolean isRegistered(IMarker marker);
+
+ /**
+ * Returns the value of the <code>LINE_NUMBER</code> attribute of the
+ * given breakpoint or -1 if the attribute is not present or
+ * an exception occurs while accessing the attribute. This is a
+ * convenience method for <code>IMarker.getAttribute(String, int)</code>.
+ *
+ * @param breakpoint the breakpoint
+ * @return the breakpoint's line number, or -1 if unknown
+ */
+ int getLineNumber(IMarker breakpoint);
+
+ /**
+ * Returns the value of the <code>CHAR_START</code> attribute of the
+ * given breakpoint or -1 if the attribute is not present, or
+ * an exception occurs while accessing the attribute. This is a
+ * convenience method for <code>IMarker.getAttribute(String, int)</code>
+ *
+ * @param breakpoint the breakpoint
+ * @return the breakpoint's char start value, or -1 if unknown
+ */
+ int getCharStart(IMarker breakpoint);
+
+ /**
+ * Returns the value of the <code>CHAR_END</code> attribute of the
+ * given breakpoint or -1 if the attribute is not present or
+ * an exception occurs while accessing the attribute.
+ * This is a convenience method for <code>IMarker.getAttribute(String, int)</code>.
+ *
+ * @param breakpoint the breakpoint
+ * @return the breakpoint's char end value, or -1 if unknown
+ */
+ int getCharEnd(IMarker breakpoint);
+
+ /**
+ * Returns the value of the <code>MODEL_IDENTIFIER</code> attribute of the
+ * given breakpoint or <code>null</code> if the attribute is not present or
+ * an exception occurs while accessing the attribute. This is a convenience method
+ * for <code>IMarker.getAttribute(String, String)</code>.
+ *
+ * @param breakpoint the breakpoint
+ * @return the breakpoint's debug model plug-in identifier, or <code>null</code>
+ * if an exception occurs retrieving the attribute
+ */
+ String getModelIdentifier(IMarker breakpoint);
+
+ /**
+ * Removes the given breakpoint from the breakpoint manager, and notifies all
+ * registered listeners. The marker is deleted if the <code>delete</code> flag is
+ * true. Has no effect if the given breakpoint is not currently registered.
+ *
+ * @param breakpoint the breakpoint to remove
+ * @param delete whether the breakpoint marker should be deleted
+ * @exception CoreException if an exception occurs while deleting the marker.
+ */
+ void removeBreakpoint(IMarker breakpoint, boolean delete) throws CoreException;
+
+ /**
+ * Adds the given listener to the collection of registered breakpoint listeners.
+ * Has no effect if an identical listener is already registered.
+ *
+ * @param listener the listener to add
+ */
+ void addBreakpointListener(IBreakpointListener listener);
+
+ /**
+ * Removes the given listener from the collection of registered breakpoint listeners.
+ * Has no effect if an identical listener is not already registered.
+ *
+ * @param listener the listener to remove
+ */
+ void removeBreakpointListener(IBreakpointListener listener);
+
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugConstants.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugConstants.java
new file mode 100644
index 000000000..15763c7d4
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugConstants.java
@@ -0,0 +1,66 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+/**
+ * Defines constants for the debug tools infrastructure plug-in.
+ * <p>
+ * Constants only; not intended to be implemented.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ */
+public interface IDebugConstants {
+
+ /**
+ * Debug infrastructure plug-in identifier
+ * (value <code>"org.eclipse.debug.core"</code>).
+ */
+ public static final String PLUGIN_ID = "org.eclipse.debug.core";
+
+ /**
+ * Launcher extension point identifier
+ * (value <code>"launchers"</code>).
+ */
+ public static final String EXTENSION_POINT_LAUNCHER= "launchers";
+
+ /**
+ * Root breakpoint marker type
+ * (value <code>"org.eclipse.debug.core.breakpoint"</code>).
+ */
+ public static final String BREAKPOINT_MARKER = PLUGIN_ID + ".breakpoint";
+
+ /**
+ * Line breakpoint marker type.
+ * (value <code>"org.eclipse.debug.core.lineBreakpoint"</code>).
+ */
+ public static final String LINE_BREAKPOINT_MARKER = PLUGIN_ID + ".lineBreakpoint";
+
+ /**
+ * Debug model identifier breakpoint marker attribute
+ * (value <code>"modelIdentifier"</code>).
+ * This attribute is a <code>String<code> corresponding to the identifier
+ * of a debug model plugin a breakpoint is associated with.
+ *
+ * @see org.eclipse.core.resources.IMarker.getAttribute(String, String)
+ */
+ public static final String MODEL_IDENTIFIER = "modelIdentifier";
+
+ /**
+ * Enabled breakpoint marker attribute (value <code>"enabled"</code>).
+ * The attribute is a <code>boolean</code> corresponding to the
+ * enabled state of a breakpoint.
+ *
+ * @see org.eclipse.core.resources.IMarker.getAttribute(String, boolean)
+ */
+ public final static String ENABLED= "enabled";
+
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugEventListener.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugEventListener.java
new file mode 100644
index 000000000..4d077b56e
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugEventListener.java
@@ -0,0 +1,30 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+/**
+ * A debug event listener registers with the debug model manager
+ * to receive event notification from all programs being debugged.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see DebugEvent
+ */
+public interface IDebugEventListener {
+ /**
+ * Notifies this listener of the given debug event.
+ *
+ * @param event the debug event
+ */
+ public void handleDebugEvent(DebugEvent event);
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugStatusConstants.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugStatusConstants.java
new file mode 100644
index 000000000..080681369
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IDebugStatusConstants.java
@@ -0,0 +1,61 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+/**
+ * Defines status codes relevant to the debug plug-in. When a
+ * debug exception is thrown, it contain a status object describing
+ * the cause of the exception. The status objects originating from the
+ * debug plug-in use the codes defined in this interface.
+ * <p>
+ * Constants only; not intended to be implemented.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IStatus
+ */
+public interface IDebugStatusConstants {
+
+ /**
+ * Indicates a request made of a debug element has failed
+ * on the target side.
+ */
+ public static final int TARGET_REQUEST_FAILED = 5010;
+
+ /**
+ * Indicates a request is not supported by the capabilities of a debug element.
+ * For example, a request was made to terminate an element that does not
+ * support termination.
+ */
+ public static final int NOT_SUPPORTED = 5011;
+
+ /**
+ * Indicates that a request made of a debug element or manager has failed
+ * on the client side (that is, before the request was sent to the debug target).
+ */
+ public static final int REQUEST_FAILED = 5012;
+
+ /**
+ * Indicates an internal error. This is an unexpected state.
+ */
+ public static final int INTERNAL_ERROR = 5013;
+
+ /**
+ * Indicates an improperly configured breakpoint. Breakpoints have a minimal
+ * set of required attributes as defined by the breakpoint manager.
+ *
+ * @see IBreakpointManager
+ */
+ public static final int CONFIGURATION_INVALID = 5014;
+
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunch.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunch.java
new file mode 100644
index 000000000..15066af7a
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunch.java
@@ -0,0 +1,79 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.model.*;
+import org.eclipse.core.runtime.IAdaptable;
+
+/**
+ * A launch is the result of launching a debug session
+ * and/or one or more system processes.
+ * <p>
+ * This interface is not intended to be implemented by clients. Clients
+ * should create instances of this interface by using the implementation
+ * provided by the class <code>Launch</code>.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see Launch
+ */
+public interface ILaunch extends ITerminate, IAdaptable {
+ /**
+ * Returns the children of this launch - at least one of a debug target
+ * and/or one or more processes.
+ *
+ * @return an array (element type:<code>IDebugTarget</code> or <code>IProcess</code>)
+ */
+ Object[] getChildren();
+ /**
+ * Returns the debug target associated with this launch, or <code>null</code>
+ * if no debug target is associated with this launch.
+ *
+ * @return the debug target associated with this launch, or <code>null</code>
+ */
+ IDebugTarget getDebugTarget();
+ /**
+ * Returns the object that was launched. Cannot return <code>null</code>.
+ *
+ * @return the launched object
+ */
+ Object getElement();
+ /**
+ * Returns the launcher that was used to launch. Cannot return <code>null</code>.
+ *
+ * @return the launcher
+ */
+ ILauncher getLauncher();
+ /**
+ * Returns the processes that were launched,
+ * or an empty collection if no processes were launched.
+ *
+ * @return array of processes
+ */
+ IProcess[] getProcesses();
+ /**
+ * Returns the source locator to use for locating source elements for
+ * the debug target associated with this launch, or <code>null</code>
+ * if source mapping is not supported.
+ *
+ * @return the source locator
+ */
+ ISourceLocator getSourceLocator();
+ /**
+ * Returns the mode of this launch - one of the mode constants defined by
+ * the launch manager.
+ *
+ * @return the launch mode
+ * @see ILaunchManager
+ */
+ public String getLaunchMode();
+
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchListener.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchListener.java
new file mode 100644
index 000000000..bb359ca03
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchListener.java
@@ -0,0 +1,36 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+/**
+ * A launch listener is notified of launches as they
+ * are registered and deregistered with the launch manager.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see ILaunch
+ */
+public interface ILaunchListener {
+ /**
+ * Notifies this listener that the specified launch has been deregistered.
+ *
+ * @param launch the deregistered launch
+ */
+ void launchDeregistered(ILaunch launch);
+ /**
+ * Notifies this listener that the specified launch has been registered.
+ *
+ * @param launch the registered launch
+ */
+ void launchRegistered(ILaunch launch);
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchManager.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchManager.java
new file mode 100644
index 000000000..caabfb457
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILaunchManager.java
@@ -0,0 +1,151 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.model.IDebugTarget;
+import org.eclipse.debug.core.model.IProcess;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IAdaptable;
+
+/**
+ * The launch manager manages the set of registered launches, maintaining
+ * a collection of active processes and debug targets. Clients interested
+ * in launch notification may register with the launch manager.
+ * <p>
+ * For convenience, a default launcher may be associated with a project.
+ * The preference is stored as a persistent property with the project.
+ * The debug UI plug-in uses this preference to help determine which
+ * launcher to invoke when the the run or debug button is pressed, based on
+ * the selection in the workbench. If a launcher cannot be determined,
+ * the user is prompted to choose a launcher.
+ * </p>
+ * <p>
+ * Clients are not intended to implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see ILaunch
+ * @see ILaunchListener
+ */
+public interface ILaunchManager extends IAdaptable {
+ /**
+ * A launch in a normal, non-debug mode(value <code>"run"</code>).
+ */
+ public static final String RUN_MODE= "run";
+ /**
+ * A launch in a special debug mode (value <code>"debug"</code>).
+ */
+ public static final String DEBUG_MODE= "debug";
+
+ /**
+ * Adds the given listener to the collection of registered launch listeners.
+ * Has no effect if an identical listener is already registerd.
+ *
+ * @param listener the listener to register
+ */
+ void addLaunchListener(ILaunchListener listener);
+ /**
+ * Deregisters the specified launch and notifies listeners. Has no effect
+ * if an identical launch is not already registered.
+ *
+ * @param launch the launch to deregister
+ */
+ void deregisterLaunch(ILaunch launch);
+ /**
+ * Returns the launch the given process is contained in, or <code>null</code>
+ * no registered launches contains the process.
+ *
+ * @param process the process for which to find a launch
+ * @return the launch containing the process, or <code>null</code> if none
+ */
+ ILaunch findLaunch(IProcess process);
+ /**
+ * Returns the launch the given debug target is contained
+ * in, or <code>null</code> no registered launches contain the debug target.
+ *
+ * @param target the debug target for which to find a launch
+ * @return the launch containing the debug target, or <code>null</code> if none
+ */
+ ILaunch findLaunch(IDebugTarget target);
+ /**
+ * Returns the collection of debug targets currently registered with this
+ * launch manager.
+ *
+ * @return an array of debug targets
+ */
+ IDebugTarget[] getDebugTargets();
+ /**
+ * Returns the default launcher for the given project,
+ * or <code>null</code> if no default launcher has been set.
+ * The default launcher is stored as a persistent property
+ * with a project.
+ *
+ * @param project the project for which to retrieve a default launcher
+ * @return the defualt launcher, or <code>null</code> if none
+ * @exception CoreException if an error occurs accessing the
+ * persistent property
+ */
+ ILauncher getDefaultLauncher(IProject project) throws CoreException;
+
+ /**
+ * Returns the collection of registered launchers that can operate in the
+ * specified mode - run or debug.
+ *
+ * @return an array of launchers
+ */
+ ILauncher[] getLaunchers(String mode);
+
+ /**
+ * Returns the collection of registered launchers.
+ *
+ * @return an array of launchers
+ */
+ ILauncher[] getLaunchers();
+ /**
+ * Returns the collection of launches currently registered
+ * with this launch manager.
+ *
+ * @return an array of launches
+ */
+ ILaunch[] getLaunches();
+ /**
+ * Returns the collection of processes currently registered with this
+ * launch manager.
+ *
+ * @return an array of processes
+ */
+ IProcess[] getProcesses();
+ /**
+ * Registers the specified launch with this launch manager.
+ * Has no effect if an identical launch is already registered.
+ *
+ * @param launch the launch to register
+ */
+ void registerLaunch(ILaunch launch);
+ /**
+ * Removes the given listener from the collection of registered launch listeners.
+ * Has no effect if an identical listener is not already registerd.
+ *
+ * @param listener the listener to deregister
+ */
+ void removeLaunchListener(ILaunchListener listener);
+ /**
+ * Sets the default launcher for the given project as a persistent property.
+ *
+ * @param project the project for which to set the preference
+ * @param launcher the launcher preference
+ * @exception CoreException if an error occurs setting the persistent property
+ */
+ void setDefaultLauncher(IProject project, ILauncher launcher) throws CoreException;
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/ILauncher.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILauncher.java
new file mode 100644
index 000000000..25568c622
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/ILauncher.java
@@ -0,0 +1,96 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.model.ILauncherDelegate;
+import org.eclipse.core.runtime.IConfigurationElement;
+import java.util.Set;
+
+/**
+ * A launcher is a proxy to a launcher extension (<code>"org.eclipse.debug.core.launchers"</code>).
+ * It manages the attributes of a launcher extension, and lazily instantiates the
+ * delegate when required.
+ * <p>
+ * This interface is not intended to be implemented by clients. Clients
+ * that define a launcher extension implement the <code>ILauncherDelegate</code>
+ * interface.
+ * </p>
+ * <p>
+ * <b>NOTE:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see ILauncherDelegate
+ */
+public interface ILauncher {
+ /**
+ * Returns the result of invoking this underlying launcher extension's launch
+ * method. This causes the extension to be instantiated (if not already).
+ *
+ * @param elements the elements providing context for the launch
+ * @param mode the mode in which to launch - run or debug
+ * @return whether the launch was successful
+ * @see ILauncherDelegate
+ */
+ boolean launch(Object[] elements, String mode);
+
+ /**
+ * Returns the modes that the underlying launcher extension
+ * supports - run and/or debug. This will not cause the extension to
+ * be instantiated.
+ *
+ * @return a set of <code>String</code> constants - one or both of
+ * <code>ILaunchManager.RUN_MODE</code>, <code>ILaunchManager.DEBUG_MODE</code>
+ * @see ILaunchManager
+ */
+ Set getModes();
+
+ /**
+ * Returns the identifier of the perspective associated with the
+ * underlying launcher extension. This attribute determines the layout
+ * used by the debug UI plug-in when presenting this launch.
+ * This will not cause the extension to be instantiated.
+ *
+ * @return a perspective identifier, as defined by the
+ * <code>"org.eclipse.ui.perspective"</code> extension point
+ */
+ String getPerspectiveIdentifier();
+
+ /**
+ * Returns the label defined by the underlying launcher extension.
+ * This will not cause the extension to be instantiated.
+ *
+ * @return a human readable label
+ */
+ String getLabel();
+
+ /**
+ * Returns the configuration element associated with the underlying
+ * extension. This will not cause the extension to be instantiated.
+ *
+ * @return the extension's configuration element
+ */
+ IConfigurationElement getConfigurationElement();
+
+ /**
+ * Returns the unique identifier of the underlying launcher extension.
+ * This will not cause the extension to be instantiated.
+ *
+ * @return the extension's identifier attribute
+ */
+ String getIdentifier();
+
+ /**
+ * Returns the underlying launcher delegate associated with this
+ * launcher. This causes the launcher delegate to be instantiated (if
+ * not already).
+ *
+ * @return the underlying launcher extension
+ */
+ ILauncherDelegate getDelegate();
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/IStreamListener.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/IStreamListener.java
new file mode 100644
index 000000000..6a642f559
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/IStreamListener.java
@@ -0,0 +1,34 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.model.IStreamMonitor;
+
+/**
+ * An stream listener is notified of changes
+ * to a stream monitor.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IStreamMonitor
+ */
+public interface IStreamListener {
+ /**
+ * Notifies this listener that text has been appended to
+ * the given stream monitor.
+ *
+ * @param text the appended text
+ * @paran monitor the stream monitor to which text was appended
+ */
+ public void streamAppended(String text, IStreamMonitor monitor);
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/Launch.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/Launch.java
new file mode 100644
index 000000000..983028b36
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/Launch.java
@@ -0,0 +1,259 @@
+package org.eclipse.debug.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.model.*;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.MultiStatus;
+import org.eclipse.core.runtime.PlatformObject;
+import java.util.*;
+
+/**
+ * An implementation of <code>ILaunch</code>.
+ * <p>
+ * Clients may instantiate this class. Clients may subclass this class.
+ * All of the methods in this class that are part of the launcher interface are
+ * final. Clients that subclass this class are not intended to change the behavior
+ * or implementation of the provided methods. Subclassing is only intended
+ * to add additional information to a specific launch. For example, a client that
+ * implements a launch object representing a Java launch might store a classpath
+ * with the launch.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see ILaunch
+ * @see ILaunchManager
+ */
+
+public class Launch extends PlatformObject implements ILaunch {
+ /**
+ * Shared, immutable empty collection used for efficiency.
+ */
+ private static List fgEmptyChildren= Collections.EMPTY_LIST;
+
+ /**
+ * The target being debugged, or <code>null</code> if
+ * there is no debug target.
+ */
+ private IDebugTarget fTarget= null;
+
+ /**
+ * The element that was launched.
+ */
+ private Object fElement= null;
+
+ /**
+ * The launcher that was used.
+ */
+ private ILauncher fLauncher= null;
+
+ /**
+ * The system processes resulting from the launch.
+ */
+ private IProcess[] fProcesses= null;
+
+ /**
+ * The source locator to use in the debug session
+ * or <code>null</code> if not available.
+ */
+ private ISourceLocator fLocator= null;
+
+ /**
+ * The mode this launch was launched in.
+ */
+ private String fMode;
+
+ /**
+ * Collection of children.
+ */
+ private List fChildren= null;
+
+ /**
+ * Constructs a launch based on the specified attributes. A launch must
+ * have at least one of a process or debug target.
+ *
+ * @param launcher the launcher that created this launch
+ * @param mode the mode of this launch - run or debug
+ * @param locator the source locator to use for this debug session, or
+ * <code>null</code> if not supported
+ * @param processes the processes created by this launch, empty
+ * or <code>null</code> if none
+ * @param target the debug target created by this launch, or <code>null</code>
+ * if none
+ */
+ public Launch(ILauncher launcher, String mode, Object launchedElement, ISourceLocator locator, IProcess[] processes, IDebugTarget target) {
+ super();
+ fLauncher= launcher;
+ fElement= launchedElement;
+ fLocator= locator;
+ if (processes == null) {
+ fProcesses= new IProcess[0];
+ } else {
+ fProcesses= processes;
+ }
+ fTarget= target;
+ fMode= mode;
+ initialize();
+ }
+
+ /**
+ * @see ITerminate
+ */
+ public final boolean canTerminate() {
+ return !isTerminated();
+ }
+
+ /**
+ * @see ILaunch
+ */
+ public final Object[] getChildren() {
+ return fChildren.toArray();
+ }
+
+ /**
+ * @see ILaunch
+ */
+ public final IDebugTarget getDebugTarget() {
+ return fTarget;
+ }
+
+ /**
+ * @see ILaunch
+ */
+ public final Object getElement() {
+ return fElement;
+ }
+
+ /**
+ * @see ILaunch
+ */
+ public final ILauncher getLauncher() {
+ return fLauncher;
+ }
+
+ /**
+ * @see ILaunch
+ */
+ public final IProcess[] getProcesses() {
+ return fProcesses;
+ }
+
+ /**
+ * @see ILaunch
+ */
+ public final ISourceLocator getSourceLocator() {
+ return fLocator;
+ }
+
+ /**
+ * Build my children collection.
+ */
+ private final void initialize() {
+
+ IProcess[] ps= getProcesses();
+ if (ps != null) {
+ fChildren= new ArrayList(ps.length + 1);
+ for (int i= 0; i < ps.length; i++) {
+ fChildren.add(ps[i]);
+ }
+ }
+ if (getDebugTarget() != null) {
+ if (fChildren == null) {
+ fChildren= new ArrayList(1);
+ }
+ fChildren.add(getDebugTarget());
+ }
+ if (fChildren == null) {
+ fChildren= fgEmptyChildren;
+ }
+ }
+
+ /**
+ * @see ITerminate
+ */
+ public final boolean isTerminated() {
+ Iterator children= fChildren.iterator();
+ while (children.hasNext()) {
+ ITerminate t= (ITerminate) children.next();
+ if (!t.isTerminated()) {
+ if (t instanceof IDisconnect) {
+ IDisconnect d= (IDisconnect)t;
+ if (!d.isDisconnected()) {
+ return false;
+ }
+ } else {
+ return false;
+ }
+ }
+
+ }
+ return true;
+ }
+
+ /**
+ * @see ITerminate
+ */
+ public final void terminate() throws DebugException {
+ MultiStatus status= new MultiStatus(DebugPlugin.getDefault().getDescriptor().getUniqueIdentifier(), IDebugStatusConstants.REQUEST_FAILED, "Terminate failed", null);
+ IProcess[] ps= getProcesses();
+
+ // terminate the system processes
+ if (ps != null) {
+ for (int i = 0; i < ps.length; i++) {
+ IProcess process = ps[i];
+ if (process.canTerminate()) {
+ try {
+ process.terminate();
+ } catch (DebugException e) {
+ status.merge(e.getStatus());
+ }
+ }
+ }
+ }
+
+ // disconnect debug target if it is still connected
+ IDebugTarget target= getDebugTarget();
+ if (target != null) {
+ if (target.canTerminate()) {
+ try {
+ target.terminate();
+ } catch (DebugException e) {
+ status.merge(e.getStatus());
+ }
+ } else {
+ if (target.canDisconnect()) {
+ try {
+ target.disconnect();
+ } catch (DebugException de) {
+ status.merge(de.getStatus());
+ }
+ }
+ }
+ }
+ if (status.isOK())
+ return;
+ IStatus[] children= status.getChildren();
+ if (children.length == 1) {
+ throw new DebugException(children[0]);
+ } else {
+ throw new DebugException(status);
+ }
+ }
+
+ /**
+ * @see ILaunch
+ */
+ public final String getLaunchMode() {
+ return fMode;
+ }
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IBreakpointSupport.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IBreakpointSupport.java
new file mode 100644
index 000000000..5a40d2d28
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IBreakpointSupport.java
@@ -0,0 +1,87 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.IBreakpointListener;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IMarkerDelta;
+
+/**
+ * Breakpoint support defines functionality for
+ * debug targets supporting breakpoints. The breakpoint manager
+ * automatically adds debug targets as breakpoint listeners,
+ * as launches are registered. The breakpoint
+ * manager only informs a debug target of breakpoint changes
+ * (that is, add/remove/change) if the target returns <code>true</code>
+ * from <code>supportsBreakpoint(IMarker)</code>. The breakpoint manager
+ * removes debug targets from its listener list as launches
+ * are deregistered.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ */
+public interface IBreakpointSupport extends IBreakpointListener {
+
+ /**
+ * Returns whether this target currently supports the given breakpoint.
+ * The breakpoint manager calls this method before calling an
+ * added/removed/changed method to verify this listener is interested
+ * in the given breakpoint.
+ * <p>
+ * Generally, a debug target is only interested in breakpoints that
+ * originated from its debug model, and only if the debug target has
+ * not been terminated.
+ * </p>
+ *
+ * @param breakpoint the breakpoint being added/removed/changed
+ * @return whether this target is currently interested in the breakpoint
+ */
+ boolean supportsBreakpoint(IMarker breakpoint);
+
+ /**
+ * Installs the given breakpoint in this target. The breakpoint should
+ * be deferred if it cannot be installed immediately. This method is only
+ * called if this listener supports the given breakpoint.
+ *
+ * @param breakpoint the added breakpoint
+ * @see IBreakpointListener
+ * @see #supportsBreakpoint(IMarker)
+ */
+ public void breakpointAdded(IMarker breakpoint);
+
+ /**
+ * Uninstalls the given breakpoint from this target if currently installed.
+ * This method is only called if this listener supports the given breakpoint.
+ *
+ * @param breakpoint the removed breakpoint
+ * @see IBreakpointListener
+ * @see #supportsBreakpoint(IMarker)
+ */
+ public void breakpointRemoved(IMarker breakpoint, IMarkerDelta delta);
+
+ /**
+ * An attribute of the given breakpoint has changed, as described
+ * by the delta. If the breakpoint is applicable to this target
+ * the attribute change should be reflected. For example, the enabled
+ * state may have changed, and should be updated in the target. This
+ * method is only called if this listener supports the given breakpoint.
+ *
+ * @param breakpoint the changed breakpoint
+ * @see IBreakpointListener
+ * @see #supportsBreakpoint(IMarker)
+ */
+ public void breakpointChanged(IMarker breakpoint, IMarkerDelta delta);
+
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDebugElement.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDebugElement.java
new file mode 100644
index 000000000..c30da9168
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDebugElement.java
@@ -0,0 +1,175 @@
+package org.eclipse.debug.core.model;
+
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.debug.core.DebugException;
+import org.eclipse.debug.core.ILaunch;
+
+/**
+ * A debug element represents an artifact in a program being
+ * debugged.
+ * <p>
+ * Some methods on debug elements require communication
+ * with the target program. Such methods may throw a <code>DebugException</code>
+ * with a status code of <code>TARGET_REQUEST_FAILED</code>
+ * when unable to complete a request due to a failure on the target.
+ * Methods that require communication with the target program or require
+ * the target to be in a specific state (for example, suspended), are declared
+ * as such.
+ * </p>
+ * <p>
+ * Debug elements are language independent. However, language specific
+ * features can be made available via the adpater mechanism provided by
+ * <code>IAdaptable</code>, or by extending the debug element interfaces.
+ * A debug model is responsible for declaring any special adapters
+ * its debug elements implement.
+ * </p>
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ */
+public interface IDebugElement extends IAdaptable {
+
+ /**
+ * Debug target type.
+ *
+ * @see IDebugTarget
+ */
+ public static final int DEBUG_TARGET= 0x0002;
+
+ /**
+ * Thread type.
+ *
+ * @see IThread
+ */
+ public static final int THREAD= 0x0004;
+
+ /**
+ * Stack frame type.
+ *
+ * @see IStackFrame
+ */
+ public static final int STACK_FRAME= 0x0008;
+
+ /**
+ * Variable type.
+ *
+ * @see IVariable
+ */
+ public static final int VARIABLE= 0x0010;
+
+ /**
+ * Value type.
+ *
+ * @see IValue
+ */
+ public static final int VALUE= 0x0012;
+
+ /**
+ * Returns the children of this debug element, or an empty collection
+ * if this element has no children.
+ *
+ * @return array of debug elements
+ * @exception DebugException if unable to retrieve this element's children
+ * from the target
+ */
+ IDebugElement[] getChildren() throws DebugException;
+ /**
+ * Returns the debug target this element originated from.
+ *
+ * @return a debug target
+ */
+ IDebugTarget getDebugTarget();
+ /**
+ * Returns the type of this element, encoded as an integer - one
+ * of the constants defined in this interface.
+ *
+ * @return debug element type constant
+ */
+ int getElementType();
+ /**
+ * Returns the launch this element originated from, or
+ * <code>null</code> if this element is not registered with
+ * a launch. This is a convenience method for
+ * <code>ILaunchManager.findLaunch(getDebugTarget())</code>.
+ *
+ * @return this element's launch, or <code>null</code> if not registered
+ */
+ ILaunch getLaunch();
+ /**
+ * Returns the name of this element. Name format is debug model
+ * specific, and should be specified by a debug model.
+ *
+ * @return this element's name
+ * @exception DebugException if unable to retrieve this element's name from
+ * the target
+ */
+ String getName() throws DebugException;
+ /**
+ * Returns the parent of this debug element, or <code>null</code>
+ * if this element has no parent.
+ *
+ * @return this element's parent, or <code>null</code> if none
+ */
+ IDebugElement getParent();
+ /**
+ * Returns the process associated with this debug element,
+ * or <code>null</code> if no process is associated with this element.
+ * This is a convenience method - it returns the process associated with
+ * this element's debug target, if any.
+ *
+ * @return this element's process, or <code>null</code> if none
+ */
+ IProcess getProcess();
+ /**
+ * Returns the source locator that can be used to locate source elements
+ * associated with this element or <code>null</code> if source lookup
+ * is not supported. This is a convenience method - it
+ * returns the source locator associated with this element's launch.
+ *
+ * @return this element's source locator, or <code>null</code> if none
+ */
+ ISourceLocator getSourceLocator();
+ /**
+ * Returns the stack frame containing this element,
+ * or <code>null</code> if this element is not contained in a stack frame.
+ *
+ * @return this element's stack frame, or <code>null</code> if none
+ */
+ IStackFrame getStackFrame();
+ /**
+ * Returns the thread containing this element,
+ * or <code>null</code> if this element is not contained in a thread.
+ *
+ * @return this element's thread, or <code>null</code> if none
+ */
+ IThread getThread();
+ /**
+ * Returns whether this element has children.
+ *
+ * @return whether this element has children
+ * @exception DebugException if unable to determine if this element has children
+ */
+ boolean hasChildren() throws DebugException;
+ /**
+ * Returns the unique identifier of the plug-in
+ * this debug element originated from.
+ *
+ * @return plug-in identifier
+ */
+ String getModelIdentifier();
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDebugTarget.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDebugTarget.java
new file mode 100644
index 000000000..3d410b5a1
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDebugTarget.java
@@ -0,0 +1,52 @@
+package org.eclipse.debug.core.model;
+
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import java.util.List;
+
+/**
+ * A debug target is a debuggable execution context. For example, a debug target
+ * may represent a debuggable process or a virtual machine. A debug target is the root
+ * of the debug element hierarchy. A debug target has element type <code>DEBUG_TARGET</code>,
+ * children of type <code>THREAD</code>, and no parent. Minimally, a debug target supports
+ * the following capabilities:
+ * <ul>
+ * <li>terminate
+ * <li>suspend/resume
+ * <li>breakpoints
+ * <li>diconnect
+ * </ul>
+ * <p>
+ * Generally, launching a debug session results in the creation of a
+ * debug target. Launching is a client responsibility, as is debug target
+ * creation.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see ITerminate
+ * @see ISuspendResume
+ * @see IBreakpointSupport
+ * @see IDisconnect
+ * @see org.eclipse.debug.core.ILaunch
+ */
+public interface IDebugTarget extends IDebugElement, ITerminate, ISuspendResume, IBreakpointSupport, IDisconnect {
+ /**
+ * Returns the system process associated with this debug target
+ * or <code>null</code> if no system process is associated with
+ * this debug target.
+ */
+ IProcess getProcess();
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDisconnect.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDisconnect.java
new file mode 100644
index 000000000..8c08860c6
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IDisconnect.java
@@ -0,0 +1,51 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.DebugException;
+
+/**
+ * Provides the ability to end a debug session with a target program
+ * and allow the target to continue running.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IDebugTarget
+ */
+public interface IDisconnect {
+ /**
+ * Returns whether this element can currently disconnect.
+ *
+ * @return whether this element can currently disconnect
+ */
+ boolean canDisconnect();
+ /**
+ * Disconnects this element from its target. Generally, disconnecting
+ * ends a debug session with a debug target, but allows the target
+ * program to continue running.
+ *
+ * @exception DebugException on failure. Reasons include:<ul>
+ * <li>TARGET_REQUEST_FAILED - The request failed in the target
+ * <li>NOT_SUPPORTED - The capability is not supported by the target
+ * </ul>
+ */
+ public void disconnect() throws DebugException;
+ /**
+ * Returns whether this element is disconnected.
+ *
+ * @return whether this element is disconnected
+ */
+ public boolean isDisconnected();
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ILauncherDelegate.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ILauncherDelegate.java
new file mode 100644
index 000000000..1cb59e7d8
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ILauncherDelegate.java
@@ -0,0 +1,109 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.ILauncher;
+
+/**
+ * A launcher delegate is an implementation of the
+ * <code>org.eclipse.debug.core.launchers</code> extension point. The
+ * debug plug-in creates a proxy to each launcher extension, and
+ * lazily instantiates an extension when required. A launch delegate
+ * starts a debug session with a specific debug model, and/or
+ * launches one or more system processes, registering the result
+ * with the launch manager.
+ * <p>
+ * A launcher extension is defined in <code>plugin.xml</code>.
+ * Following is an example definition of a launcher extension.
+ * <pre>
+ * &lt;extension point="org.eclipse.debug.core.launchers"&gt;
+ * &lt;launcher
+ * id="com.example.ExampleIdentifier"
+ * class="com.example.ExmapleLauncher"
+ * modes="run, debug"
+ * label="Example Launcher"
+ * wizard="com.example.ExampleLaunchWizard"
+ * layout="com.example.JavaLayout"&gt;
+ * &lt;/launcher&gt;
+ * &lt;/extension&gt;
+ * </pre>
+ * The attributes are specified as follows:
+ * <ul>
+ * <li><code>id</code> specifies a unique identifier for this launcher.</li>
+ * <li><code>class</code> specifies the fully qualified name of the java class
+ * that implements this interface.</li>
+ * <li><code>modes</code> specifies a comma separated list of the modes this
+ * launcher supports - <code>"run"</code> and/or <code>"debug</code>.</li>
+ * <li><code>label</code> specifies a human readable label for this launcher
+ * extension.</li>
+ * <li><code>wizard</code> specifies the fully qualified name of the java class
+ * that implements <code>org.eclipse.debug.ui.ILaunchWizard</code>. The debug UI
+ * may invoke the wizard to perform a launch, or this launcher extension
+ * may present the wizard when asked to launch.</li>
+ * <li></code>layout</code> specifies the identifier of a layout that should be
+ * used to present the resulting launch.</li>
+ * </ul>
+ * </p>
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see org.eclipse.debug.core.ILaunch
+ * @see org.eclipse.debug.core.Launch
+ * @see org.eclipse.debug.core.ILaunchManager
+ * @see org.eclipse.debug.core.ILauncher
+ */
+public interface ILauncherDelegate {
+ /**
+ * Notifies this launcher delegate to launch in the given mode,
+ * register the resulting launch with the launch manager.
+ * Returns <code>true</code> if successful, otherwise <code>false</code>.
+ * This typically results in the creation of one or more processes and/or
+ * a debug target. The collection of elements provides context for
+ * launch. The determination of which or how many objects to launch
+ * is launcher dependent. This method blocks until the launch is
+ * complete. The given launcher is the owner of this delegate.
+ * <p>
+ * For example, when the debug UI invokes a launcher, the
+ * collection of elements passed in represent the selected elements
+ * in the UI, and the mode specified will be run or debug (depending on
+ * which launch button was pressed). A launcher will generally examine the
+ * element collection to determine what to launch. For example, if the
+ * collection contains one launchable program, or one runnable program
+ * can be inferred from the collection, the launcher will launch
+ * that program. If the collection contains more than one runnable
+ * program, or more than one runnable program can be inferred from the
+ * collection, the launcher may ask the user to select a program to launch.
+ * </p>
+ * <p>
+ * Launching the program itself usually requires running an external
+ * program specific to a debug architecture/debug model, and wrapping the
+ * result in a debug target or process that can be registered in a launch object.
+ * </p>
+ *
+ * @param elements an array of objects providing a context for the launch
+ * @param mode run or debug (as defined by <code>ILaunchManager.RUN_MODE</code>,
+ * <code>ILaunchManager.DEBUG_MODE</code>)
+ * @param launcher the proxy to this lazily instantiated extension which needs
+ * to be supplied in the resulting launch object
+ * @return whether the launch succeeded
+ *
+ * @see org.eclipse.debug.core.ILaunch
+ * @see org.eclipse.debug.core.Launch
+ * @see IDebugTarget
+ * @see IProcess
+ * @see org.eclipse.debug.core.ILaunchManager#registerLaunch
+ */
+ boolean launch(Object[] elements, String mode, ILauncher launcher);
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IProcess.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IProcess.java
new file mode 100644
index 000000000..4fd4c79f0
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IProcess.java
@@ -0,0 +1,75 @@
+package org.eclipse.debug.core.model;
+
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.ILaunch;
+import org.eclipse.core.runtime.IAdaptable;
+
+/**
+ * A process represents a program running in normal (non-debug) mode.
+ * Processes support setting and getting of client defined attributes.
+ * This way, clients can annotate a process with any extra information
+ * important to them. For example, classpath annotations, or command
+ * line arguments used to launch the process may be important to a client.
+ * <p>
+ * Clients may implement this interface, however, the debug plug-in
+ * provides an implementation of this interface for a
+ * <code>java.lang.Process</code>.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see org.eclipse.debug.core.DebugPlugin#newProcess(Process, String)
+ */
+public interface IProcess extends IAdaptable, ITerminate {
+
+ /**
+ * Returns a human-readable label for this process.
+ *
+ * @return a label
+ */
+ String getLabel();
+ /**
+ * Returns the <code>ILaunch</code> this element originated from, or
+ * <code>null</code> if this element has not yet been registered with
+ * an <code>ILaunch</code>. This is a convenience method for
+ * <code>ILaunchManager.findLaunch(IProcess)</code>.
+ *
+ * @return the launch this process is contained in
+ */
+ ILaunch getLaunch();
+ /**
+ * Returns a proxy to the standard input, output, and error streams
+ * for this process, or <code>null</code> if not supported.
+ *
+ * @return a streams proxy, or <code>null</code> if not supported
+ */
+ IStreamsProxy getStreamsProxy();
+
+ /**
+ * Sets the value of a client defined attribute.
+ *
+ * @param key the attribute key
+ * @param value the attribute value
+ */
+ void setAttribute(String key, String value);
+
+ /**
+ * Returns the value of a client defined attribute.
+ *
+ * @param key the attribute key
+ * @return value the attribute value, or <code>null</code> if undefined
+ */
+ String getAttribute(String key);
+
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ISourceLocator.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ISourceLocator.java
new file mode 100644
index 000000000..ec5f7de14
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ISourceLocator.java
@@ -0,0 +1,68 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.model.IStackFrame;
+
+/**
+ * A source locator locates source elements for stack frames. Each
+ * debug session launch (optionally) specifies a source locator which is
+ * used to locate source for that debug session. If a launch does not
+ * provide a source locator, source cannot not be displayed.
+ * Abstraction of source lookup allows clients to hide implementation
+ * details of source location and representation.
+ * <p>
+ * Generally, an implementor of a debug model will also implement launchers
+ * and source locators that work together as a whole. That is, the implementation
+ * if a source locator will have knowledge of how to locate a source element
+ * for a stack frame. For example, a Java stack frame could define API which
+ * specifies a source file name. A Java source locator would use this information
+ * to locate the associated file in the workspace.
+ * </p>
+ * <p>
+ * Source is displayed by the debug UI plug-in. The debug UI uses a source locator
+ * to resolve an object representing the source for a stack frame, and then uses
+ * a debug model presentation to determine the editor and editor input to use to
+ * display the actual source in an editor.
+ * </p>
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see org.eclipse.debug.core.ILaunch
+ * @see IStackFrame
+ * @see org.eclipse.debug.ui.IDebugModelPresentation
+ */
+public interface ISourceLocator {
+
+ /**
+ * Returns a source element that corresponds to the given stack frame, or
+ * <code>null</code> if a source element could not be located. The object returned
+ * by this method will be used by the debug UI plug-in to display source.
+ * The debug UI uses the debug model presentation associated
+ * with the given stack frame's debug model to translate a source object into an
+ * {editor input, editor id} pair in which to display source.
+ * <p>
+ * For example, a java source locator could return an object representing a
+ * compilation unit or class file. The java debug model presentation would
+ * then be responsible for providing an editor input and editor id for each
+ * compilation unit and class file such that the debug UI could display source.
+ * </p>
+ *
+ * @param stackFrame the stack frame for which to locate source
+ * @return an object representing a source element.
+ */
+ Object getSourceElement(IStackFrame stackFrame);
+
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStackFrame.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStackFrame.java
new file mode 100644
index 000000000..cc67dc053
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStackFrame.java
@@ -0,0 +1,60 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.DebugException;
+
+/**
+ * A stack frame represents a stack frame in a suspended thread. A
+ * stack frame has element type <code>STACK_FRAME</code>, and a parent
+ * of type <code>THREAD</code>. The children of a stack frame are of
+ * type <code>VARIABLE</code>, and represent the visible variables in
+ * the stack frame. Minimally, a stack frame supports
+ * the following capabilities:
+ * <ul>
+ * <li>suspend/resume (convenience to resume this stack frame's thread)
+ * <li>stepping
+ * </ul>
+ * <p>
+ * An implementation may choose to re-use or discard
+ * stack frames on iterative thread suspensions. Clients
+ * cannot assume that stack frames are identical or equal across
+ * iterative thread suspensions and must check for equality on iterative
+ * suspensions if they wish to re-use the objects.
+ * </p>
+ * <p>
+ * An implementation that preserves equality
+ * across iterative suspensions may display more desirable behavior in
+ * some clients. For example, if stack frames are preserved
+ * while stepping, a UI client would be able to update the UI incrementally,
+ * rather than collapse and redraw the entire list.
+ * </p>
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see ISuspendResume
+ * @see IStep
+ */
+public interface IStackFrame extends IDebugElement, IStep, ISuspendResume {
+ /**
+ * Returns the line number of the instruction pointer in
+ * this stack frame that corresponds to a line in an associated source
+ * element, or <code>-1</code> if line number information
+ * is unavailable.
+ *
+ * @return line number of instruction pointer in this stack frame
+ * @exception DebugException if unable to retrieve this stack frame's line number
+ * from the target
+ */
+ int getLineNumber() throws DebugException;
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStep.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStep.java
new file mode 100644
index 000000000..4a31a6da2
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStep.java
@@ -0,0 +1,91 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.DebugException;
+
+/**
+ * Provides the ability to step into, over, and return
+ * from the current statement in a thread.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ */
+public interface IStep {
+ /**
+ * Returns whether this element can currently perform a step into.
+ *
+ * @return whether this element can currently perform a step into
+ */
+ boolean canStepInto();
+ /**
+ * Returns whether this element can currently perform a step over.
+ *
+ * @return whether this element can currently perform a step over
+ */
+ boolean canStepOver();
+ /**
+ * Returns whether this element can currently perform a step return.
+ *
+ * @return whether this element can currently perform a step return
+ */
+ boolean canStepReturn();
+ /**
+ * Returns whether this element is currently stepping.
+ * <p>
+ * For example, a thread is considered to be stepping
+ * after the <code>stepOver</code> call until the step over is completed,
+ * a breakpoint is reached, an exception is thrown, or the thread or is
+ * terminated.
+ * </p>
+ *
+ * @return whether this element is currently stepping
+ */
+ public boolean isStepping();
+ /**
+ * Steps into the current statement, generating <code>RESUME</code>
+ * and <code>SUSPEND</code> events for this thread. Can only be called
+ * when this thread is suspended. Implementations may choose to implement
+ * stepping as blocking or non-blocking.
+ *
+ * @exception DebugException on failure. Reasons include:<ul>
+ * <li>TARGET_REQUEST_FAILED - The request failed in the target</li>
+ * <li>NOT_SUPPORTED - The capability is not supported by the target</li>
+ * </ul>
+ */
+ void stepInto() throws DebugException;
+ /**
+ * Steps over the current statement, generating <code>RESUME</code>
+ * and <code>SUSPEND</code> events for this thread. Can only be called
+ * when this thread is suspended. Implementations may choose to implement
+ * stepping as blocking or non-blocking.
+ *
+ * @exception DebugException on failure. Reasons include:<ul>
+ * <li>TARGET_REQUEST_FAILED - The request failed in the target</li>
+ * <li>NOT_SUPPORTED - The capability is not supported by the target</li>
+ * </ul>
+ */
+ void stepOver() throws DebugException;
+ /**
+ * Steps to the next return statement in the current scope,
+ * generating <code>RESUME</code> and <code>SUSPEND</code> events for
+ * this thread. Can only be called when this thread is suspended.
+ * Implementations may choose to implement stepping as blocking or non-blocking.
+ *
+ * @exception DebugException on failure. Reasons include:<ul>
+ * <li>TARGET_REQUEST_FAILED - The request failed in the target</li>
+ * <li>NOT_SUPPORTED - The capability is not supported by the target</li>
+ * </ul>
+ */
+ void stepReturn() throws DebugException;
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStreamMonitor.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStreamMonitor.java
new file mode 100644
index 000000000..a74b8636e
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStreamMonitor.java
@@ -0,0 +1,49 @@
+package org.eclipse.debug.core.model;
+import org.eclipse.debug.core.IStreamListener;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+/**
+ * A stream monitor manages the contents of a stream a process
+ * is writing to, and notifies registered listeners of changes in
+ * the stream.
+ * <p>
+ * Clients may implement this interface. Generally, a client that
+ * provides an implementation of the <code>IStreamsProxy</code>
+ * interface must also provide an implementation of this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IStreamsProxy
+ */
+public interface IStreamMonitor {
+ /**
+ * Adds the given listener to the registered listeners.
+ * Has no effect if an identical listener is already registered.
+ *
+ * @param the listener to add
+ */
+ public void addListener(IStreamListener listener);
+ /**
+ * Returns the current contents of the stream. An empty
+ * String is returned if the stream is empty.
+ *
+ * @return the stream contents as a <code>String</code>
+ */
+ public String getContents();
+ /**
+ * Removes the given listener from the registered listeners.
+ * Has no effect if the listener is not already registered.
+ *
+ * @param the listener to remove
+ */
+ public void removeListener(IStreamListener listener);
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStreamsProxy.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStreamsProxy.java
new file mode 100644
index 000000000..fb87118ee
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IStreamsProxy.java
@@ -0,0 +1,58 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import java.io.IOException;
+
+/**
+ * A streams proxy acts as proxy between the streams of an
+ * process and interested clients. This abstraction allows
+ * implementations of <code>IProcess</code> to handle I/O related
+ * to the standard input, output, and error streams associated
+ * with a process.
+ * <p>
+ * Clients implementing the <code>IProcess</code> interface must also
+ * provide an implementation of this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IProcess
+ * @see org.eclipse.debug.core.DebugPlugin#newProcess(Process, String)
+ */
+public interface IStreamsProxy {
+ /**
+ * Returns a monitor for the error stream of this proxy's process,
+ * or <code>null</code> if not supported.
+ * The monitor is connected to the error stream of the
+ * associated process.
+ *
+ * @return an input stream monitor, or <code>null</code> if none
+ */
+ public IStreamMonitor getErrorStreamMonitor();
+ /**
+ * Returns a monitor for the output stream of this proxy's process,
+ * or <code>null</code> if not supported.
+ * The monitor is connected to the output stream of the
+ * associated process.
+ *
+ * @return an input stream monitor, or <code>null</code> if none
+ */
+ public IStreamMonitor getOutputStreamMonitor();
+ /**
+ * Writes the given text to the output stream connected to the
+ * standard input stream of a this proxy's process.
+ *
+ * @exception IOException when an error occurs writing to the
+ * underlying <code>OutputStream</code>.
+ *
+ */
+ public void write(String input) throws IOException;
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ISuspendResume.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ISuspendResume.java
new file mode 100644
index 000000000..9aea82aee
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ISuspendResume.java
@@ -0,0 +1,64 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.DebugException;
+
+/**
+ * Provides the ability to suspend and resume a thread
+ * or debug target.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ */
+public interface ISuspendResume {
+ /**
+ * Returns whether this element can currently be resumed.
+ *
+ * @return whether this element can currently be resumed
+ */
+ public boolean canResume();
+ /**
+ * Returns whether this element can currently be suspended.
+ *
+ * @return whether this element can currently be suspended
+ */
+ public boolean canSuspend();
+ /**
+ * Returns whether this element is currently suspened.
+ *
+ * @return whether this element is currently suspened
+ */
+ public boolean isSuspended();
+ /**
+ * Causes this element to resume its execution. Has no effect
+ * on an element that is not suspended. This call is non-blocking.
+ *
+ * @exception DebugException on failure. Reasons include:<ul>
+ * <li>TARGET_REQUEST_FAILED - The request failed in the target
+ * <li>NOT_SUPPORTED - The capability is not supported by the target
+ * </ul>
+ */
+ public void resume() throws DebugException;
+ /**
+ * Causes this element to suspend its execution.
+ * Has no effect on an already suspened element.
+ * Implementations may be blocking or non-blocking.
+ *
+ * @exception DebugException on failure. Reasons include:<ul>
+ * <li>TARGET_REQUEST_FAILED - The request failed in the target
+ * <li>NOT_SUPPORTED - The capability is not supported by the target
+ * </ul>
+ */
+ public void suspend() throws DebugException;
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ITerminate.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ITerminate.java
new file mode 100644
index 000000000..6c25dd40a
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/ITerminate.java
@@ -0,0 +1,47 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.DebugException;
+
+/**
+ * Provides the ability to terminate an execution
+ * context - for example, a thread, debug target or process.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ */
+public interface ITerminate {
+ /**
+ * Returns whether this element can be terminated.
+ *
+ * @return whether this element can be terminated
+ */
+ boolean canTerminate();
+ /**
+ * Returns whether this element is terminated.
+ *
+ * @return whether this element is terminated
+ */
+ public boolean isTerminated();
+ /**
+ * Causes this element to terminate. Implementations may be
+ * blocking or non-blocking.
+ *
+ * @exception DebugException on failure. Reasons include:<ul>
+ * <li>TARGET_REQUEST_FAILED - The request failed in the target
+ * <li>NOT_SUPPORTED - The capability is not supported by the target
+ * </ul>
+ */
+ public void terminate() throws DebugException;
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IThread.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IThread.java
new file mode 100644
index 000000000..200b7c10c
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IThread.java
@@ -0,0 +1,57 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.DebugException;
+
+/**
+ * A thread represents a thread of execution in a debug target. A
+ * thread has element type <code>THREAD</code>, and a parent
+ * of type <code>DEBUG_TARGET</code>. The children of a thread are of
+ * type <code>STACK_FRAME</code>. A thread only has children when
+ * suspended, and children are returned in top-down order.
+ * Minimally, a thread supports the following capabilities:
+ * <ul>
+ * <li>suspend/resume
+ * <li>stepping
+ * <li>termiante
+ * </ul>
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see ISuspendResume
+ * @see IStep
+ * @see ITerminate
+ * @see IStackFrame
+ */
+
+public interface IThread extends IDebugElement, ISuspendResume, IStep, ITerminate {
+ /**
+ * Returns the priority of this thread. The meaning of this
+ * number is operating-system dependent.
+ *
+ * @return thread priority
+ * @exception DebugException if unable to retrieve this thread's priority from
+ * the target
+ */
+ int getPriority() throws DebugException;
+ /**
+ * Returns the top stack frame or <code>null</code> if there is
+ * currently no top stack frame.
+ *
+ * @return the top stack frame, or <code>null</code> if none
+ * @exception DebugException if unable to retrieve this thread's top stack frame
+ * from the target
+ */
+ IStackFrame getTopStackFrame() throws DebugException;
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IValue.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IValue.java
new file mode 100644
index 000000000..381a33834
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IValue.java
@@ -0,0 +1,100 @@
+package org.eclipse.debug.core.model;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.DebugException;
+
+/**
+ * A value represents the value of a variable.
+ * A value does not have a parent - instead it has an associated variable.
+ * A value representing a complex data structure has
+ * children of type <code>VARIABLE</code>.
+ * <p>
+ * An implementation may choose to re-use or discard
+ * values on iterative thread suspensions. Clients
+ * cannot assume that values are identical or equal across
+ * iterative thread suspensions and must check for equality on iterative
+ * suspensions if they wish to re-use the objects.
+ * </p>
+ * <p>
+ * An implementation that preserves equality
+ * across iterative suspensions may display more desirable behavior in
+ * some clients. For example, if variables are preserved
+ * while stepping, a UI client would be able to update the UI incrementally,
+ * rather than collapse and redraw the entire list or tree.
+ * </p>
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IVariable
+ */
+
+
+public interface IValue extends IDebugElement {
+
+ /**
+ * Returns a description of the type of data this value contains
+ * or references.
+ *
+ * @return reference type
+ * @exception DebugException if unable to retrieve this value's reference type
+ * name from the target
+ */
+ String getReferenceTypeName() throws DebugException;
+
+ /**
+ * Returns this value as a <code>String</code>.
+ *
+ * @return value
+ * @exception DebugException if unable to retrieve this value's value description
+ * from the target
+ */
+ String getValueString() throws DebugException;
+
+ /**
+ * Returns the name of this element. Implementations of <code>IValue</code>
+ * return <code>null</code>. Values do not have names.
+ *
+ * @return <code>null</code>
+ */
+ String getName();
+
+ /**
+ * Returns the variable this value is bound to, or <code>null</code>
+ * if this value is not bound to a variable.
+ *
+ * @return a variable, or <code>null</code> if none
+ */
+ IVariable getVariable();
+
+ /**
+ * Returns the parent of this element. Implementations of <code>IVariable</code>
+ * return <code>null</code>. Values do not have parents.
+ *
+ * @return <code>null</code>
+ */
+ IDebugElement getParent();
+
+ /**
+ * Returns whether this value is currently allocated.
+ * <p>
+ * For example, if this value represents
+ * an object that has been garbage collected, <code>false</code> would
+ * be returned.
+ * </p>
+ * @return whether this value is currently allocated
+ * @exception DebugException if unable to determine if this value is currently
+ * allocated on the target
+ */
+ boolean isAllocated() throws DebugException;
+} \ No newline at end of file
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IValueModification.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IValueModification.java
new file mode 100644
index 000000000..dc8d0f5b2
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IValueModification.java
@@ -0,0 +1,55 @@
+package org.eclipse.debug.core.model;
+
+import org.eclipse.debug.core.DebugException;
+
+/**
+ * Provides the ability to modify the value of a variable in
+ * the target.
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IVariable
+ */
+public interface IValueModification {
+
+ /**
+ * Attempts to set the value of this variable to the
+ * value of the given expression.
+ *
+ * @param expression an expression to generate a new value
+ * @exception DebugException on failure. Reasons include:<ul>
+ * <li>TARGET_REQUEST_FAILED - The request failed in the target
+ * <li>NOT_SUPPORTED - The capability is not supported by the target
+ * </ul>
+ */
+ public void setValue(String expression) throws DebugException;
+
+ /**
+ * Returns whether this varaible supports value modification.
+ *
+ * @return whether this varaible supports value modification
+ */
+ public boolean supportsValueModification();
+
+ /**
+ * Returns whether the given expression is valid to be used in
+ * setting a new value for this variable.
+ *
+ * @param expression an expression to generate a new value
+ * @return whether the expression is acceptable
+ * @exception DebugException on failure. Reasons include:<ul>
+ * <li>TARGET_REQUEST_FAILED - The request failed in the target
+ * <li>NOT_SUPPORTED - The capability is not supported by the target
+ * </ul>
+ */
+ public boolean verifyValue(String expression) throws DebugException;
+
+}
+
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IVariable.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IVariable.java
new file mode 100644
index 000000000..7ab9313c4
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/IVariable.java
@@ -0,0 +1,78 @@
+package org.eclipse.debug.core.model;
+
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.DebugException;
+
+/**
+ * A variable represents a visible variable in a stack frame,
+ * or the child of a value. A variable has a type of <code>VARIABLE</code>.
+ * A variable's parent may be of type
+ * <code>STACK_FRAME</code> or <code>VALUE</code>.
+ * Each variable has a value which may in turn
+ * have children. A variable itself does not have children.
+ * A variable may support value modification.
+ * <p>
+ * An implementation may choose to re-use or discard
+ * variables on iterative thread suspensions. Clients
+ * cannot assume that variables are identical or equal across
+ * iterative thread suspensions and must check for equality on iterative
+ * suspensions if they wish to re-use the objects.
+ * </p>
+ * <p>
+ * An implementation that preserves equality
+ * across iterative suspensions may display more desirable behavior in
+ * some clients. For example, if variables are preserved
+ * while stepping, a UI client would be able to update the UI incrementally,
+ * rather than collapse and redraw the entire list or tree.
+ * </p>
+ * <p>
+ * Clients may implement this interface.
+ * </p>
+ * <p>
+ * <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
+ * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
+ * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
+ * (repeatedly) as the API evolves.
+ * </p>
+ * @see IValue
+ * @see IStackFrame
+ * @see IValueModification
+ */
+public interface IVariable extends IDebugElement, IValueModification {
+ /**
+ * Returns the children of this elemnet. Implementations of
+ * <code>IVariable</code> return an empty collection.
+ *
+ * @return an empty collection
+ * @see IDebugElement
+ * @exception DebugException if an unable to retrieve children from
+ * the target
+ */
+ IDebugElement[] getChildren() throws DebugException;
+
+ /**
+ * Returns the value of this variable.
+ *
+ * @return variable value
+ * @exception DebugException if unable to retrieve this variable's value
+ * from the target
+ */
+ IValue getValue() throws DebugException;
+
+ /**
+ * Returns a description of the type of data this variable is
+ * declared to reference. Note that the type of a variable
+ * and the type of its value are not always the same.
+ *
+ * @return declared type of variable
+ * @exception DebugException if unable to retrieve this variables reference type
+ * name from the target
+ */
+ String getReferenceTypeName() throws DebugException;
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/model/package.html b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/package.html
new file mode 100644
index 000000000..59c1b7ba2
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/model/package.html
@@ -0,0 +1,57 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<meta name="GENERATOR" content="Microsoft FrontPage 3.0">
+<title>Eclipse Debug Tools</title>
+</head>
+
+<body bgcolor="#FFFFFF">
+
+<h3>The Debug Model</h3>
+
+<p><strong>Note:</strong> this package is part of an interim API that is still under
+development and expected to change significantly before reaching stability. It is being
+made available at this early stage to soloicit feedback from pioneering adopters on the
+understanding that any code that uses this API will almost certainly be broken
+(repeatedly) as the API evolves.</p>
+
+<p>A language independent &quot;debug model&quot; is represented by the set of interfaces
+defined in <font face="Courier">org.eclipse.debug.core.model</font>. A client implements a debug
+model by providing an implementation of these interfaces in a plug-in. (There is no
+explicit extension point that represents a debug model). Each debug architecture will have
+its own way of initiating a debug session. Generally, each debug model will provide one or
+more launchers capable of initiating a debug session. A &quot;launcher&quot; is an
+extension point defined by the debug plug-in. A launcher is responsible for starting a
+debug session, and registering the result with the debug plug-in. Launching is a client
+responsibility.</p>
+
+<p>The common elements defined by the debug plug-in are:
+
+<ul>
+ <li>Debug Target - a debug target represents a debuggable program - for example, a virtual
+ machine or a process.</li>
+ <li>Thread - a debug target may contain one or more threads</li>
+ <li>Stack Frame - a thread that is suspended may contain one or more stack frames</li>
+ <li>Variable - a stack frame may contain variables</li>
+ <li>Value - each variable has a value, and a value may contain more variables (to represent
+ complex data structures and objects)</li>
+ <li>Process - a program running in normal (non-debug) mode</li>
+</ul>
+
+<h4>Rendering &amp; Presentation</h4>
+
+<p>Debug model elements and breakpoints are displayed in the workbench. To support
+configurable and extensible presentation, the debug UI plug-in defines the <font
+face="Courier">debugModelPresentations</font> extension point. Extensions of this kind
+register for a specific debug model. It is intended that an implementation of a debug
+model will also provide an implementation of a debug model presentation. The presentation
+provides:
+
+<ul>
+ <li>an image for a debug element or breakpoint</li>
+ <li>a label for a debug element or breakpoint</li>
+ <li>an editor input that should be used to display the debug element or breakpoint</li>
+</ul>
+</body>
+</html>
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/package.html b/org.eclipse.debug.core/core/org/eclipse/debug/core/package.html
new file mode 100644
index 000000000..81476871a
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/package.html
@@ -0,0 +1,176 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<meta name="GENERATOR" content="Microsoft FrontPage 3.0">
+<title>Eclipse Debug Tools</title>
+</head>
+
+<body bgcolor="#FFFFFF">
+
+<p>Provides support for launching programs and defines interfaces for a debug model to
+support an extensible set debug architectures.</p>
+
+<h2>Package Specification</h2>
+
+<p><strong>Note</strong>: this package is part of an interim API that is still under
+development and expected to change significantly before reaching stability. It is being
+made available at this early stage to soloicit feedback from pioneering adopters on the
+understanding that any code that uses this API will almost certainly be broken
+(repeatedly) as the API evolves.</p>
+
+<p>Eclipse Debug Tools provides classes and interfaces to support the launching,
+registration, and manipulation of debuggable and non-debuggable programs. An extensible
+set of debug architectures and languages are supported by the definition of a &quot;debug
+model&quot; - a set of interfaces representing common artifacts in debuggable programs.
+The debug plug-in itself does not provide any implementations of a debug model. It is
+intended that third parties providing an integrated set of development tools for a
+specific language will also implement a debug model for that language, using an underlying
+debug architecture of their choice. For example, Java Tooling provides an implementation
+of a debug model based on the standard Java Debug Interface (JDI).</p>
+
+<h4>The Debug Model</h4>
+
+<p>The &quot;debug model&quot; is represented by the set of interfaces defined in <font
+face="Courier">org.eclipse.debug.core.model</font>. A client implements a debug model by
+providing an implementation of these interfaces in a plug-in. (There is no explicit
+extension point that represents a debug model). Each debug architecture will have its own
+way of initiating a debug session. Generally, each debug model will provide one or more
+launchers capable of initiating a debug session. A &quot;launcher&quot; is an extension
+point defined by the debug plug-in. A launcher is responsible for starting a debug
+session, and registering the result with the debug plug-in. Launching is a client
+responsibility.</p>
+
+<p>The common elements defined by the debug plug-in are:
+
+<ul>
+ <li>Debug Target - a debug target represents a debuggable program - for example, a virtual
+ machine or a process.</li>
+ <li>Thread - a debug target may contain one or more threads</li>
+ <li>Stack Frame - a thread that is suspended may contain one or more stack frames</li>
+ <li>Variable - a stack frame may contain variables</li>
+ <li>Value - each variable has a value, and a value may contain more variables (to represent
+ complex data structures and objects)</li>
+</ul>
+
+<h5>Rendering &amp; Presentation</h5>
+
+<p>Debug model elements and breakpoints are displayed in the workbench. To support
+configurable and extensible presentation, the<font face="Courier"> debugModelPresentations</font>
+extension point is used. Extensions may be registered for a specific debug model. It is
+intended that an implementation of a debug model will also provide an implementation of a
+debug model presentation. The presentation provides:
+
+<ul>
+ <li>an image for a debug element or breakpoint</li>
+ <li>a label for a debug element or breakpoint</li>
+ <li>an editor input that should be used to display the debug element or breakpoint</li>
+</ul>
+
+<h4>Breakpoints</h4>
+
+<p>Breakpoints are used to suspend the execution of a program being debugged. There are
+many kinds of breakpoints - line breakpoints, conditional line breakpoints, hit count
+breakpoints, exception breakpoints, etc. The kinds of breakpoints supported by each debug
+architecture (for example, JDI), and the information required to create those breakpoints
+is dictated by each debug architecture. Thus, Eclipse Debug Tools supports an extensible
+set of breakpoint types.</p>
+
+<p>Eclipse Debug Tools provides a breakpoint manager that maintains the collection of all
+known breakpoints. Clients add and remove breakpoints via this manager. Breakpoints are
+represented by markers in the workspace, providing persistence and an extensible set of
+breakpoint attributes. Eclipse Debug Tools defines the root breakpoint marker and the
+common line breakpoint marker, as well as the attributes for these markers. Breakpoint
+creation is a client responsibility - that is, choosing which resource to associate a
+breakpoint with.</p>
+
+<p>The breakpoint definitions in plug-in <font face="Courier New">org.eclipse.debug.core</font>
+are as follows: </p>
+<font SIZE="2">
+
+<p><font face="Courier">&lt;extension id=&quot;breakpoint&quot;
+point=&quot;org.eclipse.core.resources.markers&quot;&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;super type=&quot;org.eclipse.core.resources.marker&quot;/&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;persisted value=&quot;true&quot;/&gt;</font></font><br>
+<font face="Courier" SIZE="2">&nbsp;&nbsp;&nbsp; &lt;attribute
+name=&quot;modelIdentifier&quot;/&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;attribute name=&quot;enabled&quot;/&gt;<br>
+&lt;/extension&gt;</font></p>
+
+<p><font face="Courier" SIZE="2">&lt;extension id=&quot;lineBreakpoint&quot;
+point=&quot;org.eclipse.core.resources.markers&quot;&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;super type=&quot;org.eclipse.debug.core.breakpoint&quot;/&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;super type=&quot;org.eclipse.core.resources.textmarker&quot;/&gt;<br>
+&nbsp;&nbsp;&nbsp; &lt;persisted value=&quot;true&quot;/&gt;<br>
+&lt;/extension&gt;</font></p>
+
+<h5>Breakpoint Creation</h5>
+
+<p>The breakpoint lifecycle begins with breakpoint creation. The location in which a
+breakpoint may be placed, and the attributes that its debug target requires to install the
+breakpoint is specific to each debug model. For this reason, breakpoint creation is a
+client responsibility. Generically, the breakpoint creation scenario involves the
+following steps:
+
+<ol>
+ <li>Creation of a (subtype of the) breakpoint marker. This requires that a marker be created
+ with all appropriate attributes. For convenience, the breakpoint manager has API for
+ configuring default values for required attributes on markers.</li>
+ <li>Registration of the breakpoint marker with the breakpoint manager. A breakpoint is not
+ considered active until it is registered with the breakpoint manager.</li>
+</ol>
+
+<p>Note that verifying the location of the breakpoint is valid is also a client
+responsibility.</p>
+
+<h5>Persistence</h5>
+
+<p>Breakpoints are persisted via the standard marker mechanism. Breakpoints defined with
+the <font face="Courier New">persisted</font> attribute as <font face="Courier New">false</font>
+will not be persisted. Breakpoints are restored at workspace startup time by the
+breakpoint manager - that is, all persisted markers which are a subtype of the root
+breakpoint marker are added to the breakpoint manager. To allow for selective persistence
+of breakpoints, the root breakpoint marker defines a &quot;persisted&quot; attribute. If
+this value is set to false, the breakpoint will not be persisted.</p>
+
+<h5>Change Notification</h5>
+
+<p>As breakpoint markers are modified (created, removed, and attribute values are
+changed), resource deltas are created by the platform. The breakpoint manager translates
+pertinent resource deltas into breakpoint change notifications (breakpoint
+added/removed/changed messages). Interested listeners may register with the breakpoint
+manager. The breakpoint manager only fires change notifications for registered
+breakpoints. This simplifies breakpoint processing for clients, as resource delta
+traversal and analysis is not required. Thus clients have two options - listening to
+resource deltas from the platform, or listening to change notification from the breakpoint
+manager. However, clients should be careful to note that breakpoints marker deltas should
+only be considered as breakpoint changes if a breakpoint is currently active (registered
+with the breakpoint manager).</p>
+
+<h5>Deletion</h5>
+
+<p>Removing a breakpoint from the breakpoint manager signals the end of the breakpoint
+lifecycle. A breakpoint may be removed with the method <font face="Courier">org.eclipse.debug.core.IBreakpointManager.removeBreakpoint(IMarker)</font>,
+or by deleting the underlying marker (in the later case, the breakpoint manager notices a
+breakpoint has been deleted, and automatically removes it).</p>
+
+<h5>Extensibility</h5>
+
+<p>Clients can define new kinds of breakpoints with the appropriate plug-in XML and
+subtyping any of the defined breakpoint markers. For example, a client may define an
+exception breakpoint as a subtype of the root breakpoint, or a client might define a
+conditional breakpoint as a subtype of the line breakpoint. The breakpoint manager does
+not define generic breakpoints of these types since the attributes required are debug
+model dependent.</p>
+
+<h5>Target Notification</h5>
+
+<p>Debug targets are notified of breakpoints via the <font face="Courier New">IBreakpointListener</font>
+mechanism. The breakpoint manager only notifies debug targets of breakpoints
+added/changed/removed, after a target has been created. Since breakpoints are often in
+existence before a debug target is launched, a debug target is responsible for querying
+the breakpoint manager for breakpoints in existence when it is created - see <font
+face="Courier">org.eclipse.debug.core.IBreakpointManager.getBreakpoints(String)</font>,
+which provides a list of active breakpoints for a specific debug model.</p>
+</body>
+</html>
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/BreakpointManager.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/BreakpointManager.java
new file mode 100644
index 000000000..03114c808
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/BreakpointManager.java
@@ -0,0 +1,487 @@
+package org.eclipse.debug.internal.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.core.resources.*;
+import org.eclipse.core.runtime.*;
+import org.eclipse.debug.core.*;
+import org.eclipse.debug.core.model.IBreakpointSupport;
+import org.eclipse.debug.core.model.IDebugTarget;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Vector;
+
+/**
+ * The breakpoint manager manages all registered breakpoints
+ * for the debug plugin. It is instantiated by the debug plugin.
+ *
+ * @see IBreakpointManager
+ */
+public class BreakpointManager implements IBreakpointManager, IResourceChangeListener, ILaunchListener {
+
+ private final static String PREFIX= "breakpoint_manager.";
+ private final static String ERROR= PREFIX + "error.";
+ private final static String OLD_MARKER= ERROR + "old_marker";
+ private final static String ADAPTER= ERROR + "adapter";
+ private final static String LABEL_PROPERTY= ERROR + "label_property";
+ private final static String EXTENSION= ERROR + "extension";
+ private final static String ASSOCIATED_RESOURCE= ERROR + "associated_resource";
+ private final static String REQUIRED_ATTRIBUTES= ERROR + "required_attributes";
+ private final static String LINE_NUMBER= ERROR + "line_number";
+ private final static String CREATION_FAILED= ERROR + "creation_failed";
+ private final static String UNSUPPORTED_EXTENSION= ERROR + "unsupported_extension";
+ private final static String INSTALLATION_FAILED= ERROR + "installation_failed";
+ private final static String REMOVE_FAILED= ERROR + "remove_failed";
+ private final static String ENABLE= ERROR + "enable";
+ private final static String HIT_COUNT= ERROR + "hit_count";
+ private final static String TARGET= ERROR + "target";
+
+ /**
+ * Constants for breakpoint add/remove/change updates
+ */
+ private final static int ADDED = 0;
+ private final static int REMOVED = 1;
+ private final static int CHANGED = 2;
+
+ /**
+ * A collection of breakpoint registered with this manager.
+ *
+ */
+ protected Vector fBreakpoints;
+
+ /**
+ * Collection of breakpoint listeners.
+ */
+ protected ListenerList fBreakpointListeners= new ListenerList(6);
+
+ /**
+ * Singleton resource delta visitor
+ */
+ protected static BreakpointManagerVisitor fgVisitor;
+
+ /**
+ * The set of attributes used to configure a breakpoint
+ */
+ protected static final String[] fgBreakpointAttributes= new String[]{IDebugConstants.MODEL_IDENTIFIER, IDebugConstants.ENABLED};
+
+ /**
+ * The set of attributes used to configure a line breakpoint
+ */
+ protected static final String[] fgLineBreakpointAttributes= new String[]{IDebugConstants.MODEL_IDENTIFIER, IDebugConstants.ENABLED, IMarker.LINE_NUMBER, IMarker.CHAR_START, IMarker.CHAR_END};
+
+ /**
+ * Constructs a new breakpoint manager.
+ */
+ public BreakpointManager() {
+ fBreakpoints= new Vector(15);
+ }
+
+ /**
+ * Registers this manager as a resource change listener and launch
+ * listener. Loads the list of breakpoints from the breakpoint markers in the
+ * workspace. This method should only be called on initial startup of
+ * the debug plugin.
+ *
+ * @exception CoreException if an error occurrs retreiving breakpoint markers
+ */
+ public void startup() throws CoreException {
+ getWorkspace().addResourceChangeListener(this);
+ getLaunchManager().addLaunchListener(this);
+ IMarker[] breakpoints= null;
+ IWorkspaceRoot root= getWorkspace().getRoot();
+ breakpoints= root.findMarkers(IDebugConstants.BREAKPOINT_MARKER, true, IResource.DEPTH_INFINITE);
+
+ for (int i = 0; i < breakpoints.length; i++) {
+ IMarker marker= breakpoints[i];
+ try {
+ addBreakpoint(marker);
+ } catch (DebugException e) {
+ logError(e);
+ }
+ }
+ }
+
+ /**
+ * Removes this manager as a resource change listener
+ */
+ public void shutdown() {
+ getWorkspace().removeResourceChangeListener(this);
+ getLaunchManager().removeLaunchListener(this);
+ }
+
+
+ /**
+ * Convenience method to get the launch manager.
+ */
+ protected ILaunchManager getLaunchManager() {
+ return DebugPlugin.getDefault().getLaunchManager();
+ }
+
+ /**
+ * Convenience method to get the workspace
+ */
+ protected IWorkspace getWorkspace() {
+ return ResourcesPlugin.getWorkspace();
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public IMarker[] getBreakpoints() {
+ IMarker[] temp= new IMarker[fBreakpoints.size()];
+ fBreakpoints.copyInto(temp);
+ return temp;
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public IMarker[] getBreakpoints(String modelIdentifier) {
+ Vector temp= new Vector(fBreakpoints.size());
+ if (!fBreakpoints.isEmpty()) {
+ Iterator bps= fBreakpoints.iterator();
+ while (bps.hasNext()) {
+ IMarker bp= (IMarker) bps.next();
+ String id= getModelIdentifier(bp);
+ if (id != null && id.equals(modelIdentifier)) {
+ temp.add(bp);
+ }
+ }
+ }
+ IMarker[] m= new IMarker[temp.size()];
+ temp.copyInto(m);
+ return m;
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public int getLineNumber(IMarker breakpoint) {
+ return breakpoint.getAttribute(IMarker.LINE_NUMBER, -1);
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public int getCharStart(IMarker breakpoint) {
+ return breakpoint.getAttribute(IMarker.CHAR_START, -1);
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public int getCharEnd(IMarker breakpoint) {
+ return breakpoint.getAttribute(IMarker.CHAR_END, -1);
+ }
+
+ /**
+ * Returns the model identifier for the given breakpoint.
+ */
+ public String getModelIdentifier(IMarker breakpoint) {
+ return (String) breakpoint.getAttribute(IDebugConstants.MODEL_IDENTIFIER, (String)null);
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public boolean isEnabled(IMarker marker) {
+ return marker.getAttribute(IDebugConstants.ENABLED, true);
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public boolean isRegistered(IMarker marker) {
+ return fBreakpoints.contains(marker);
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public void removeBreakpoint(IMarker breakpoint, boolean delete) throws CoreException {
+ if (fBreakpoints.remove(breakpoint)) {
+ fireUpdate(breakpoint, null, REMOVED);
+ if (delete) {
+ breakpoint.delete();
+ }
+ }
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public void addBreakpoint(IMarker breakpoint) throws DebugException {
+ if (!fBreakpoints.contains(breakpoint)) {
+ verifyBreakpoint(breakpoint);
+ fBreakpoints.add(breakpoint);
+ fireUpdate(breakpoint, null, ADDED);
+ }
+ }
+
+ /**
+ * Verifies that the breakpoint marker has the minimal required attributes,
+ * and throws a debug exception if not.
+ */
+ protected void verifyBreakpoint(IMarker breakpoint) throws DebugException {
+ try {
+ String id= (String) breakpoint.getAttribute(IDebugConstants.MODEL_IDENTIFIER);
+ if (id == null) {
+ throw new DebugException(new Status(IStatus.ERROR, DebugPlugin.getDefault().getDescriptor().getUniqueIdentifier(),
+ IDebugStatusConstants.CONFIGURATION_INVALID, DebugCoreUtils.getResourceString(REQUIRED_ATTRIBUTES), null));
+ }
+ } catch (CoreException e) {
+ throw new DebugException(e.getStatus());
+ }
+ }
+
+ /**
+ * A resource has changed. Traverses the delta for breakpoint changes.
+ */
+ public void resourceChanged(IResourceChangeEvent event) {
+ IResourceDelta delta= event.getDelta();
+ if (delta != null) {
+ try {
+ if (fgVisitor == null) {
+ fgVisitor= new BreakpointManagerVisitor();
+ }
+ delta.accept(fgVisitor);
+ } catch (CoreException ce) {
+ logError(ce);
+ }
+ }
+ }
+
+ /**
+ * A project has been opened or closed. Updates the breakpoints for
+ * that project
+ */
+ protected void handleProjectResourceOpenStateChange(IResource project) {
+ if (!project.isAccessible()) {
+ //closed
+ Enumeration breakpoints= fBreakpoints.elements();
+ while (breakpoints.hasMoreElements()) {
+ IMarker breakpoint= (IMarker) breakpoints.nextElement();
+ IResource breakpointResource= breakpoint.getResource();
+ if (project.getFullPath().isPrefixOf(breakpointResource.getFullPath())) {
+ try {
+ removeBreakpoint(breakpoint, false);
+ } catch (CoreException e) {
+ logError(e);
+ }
+ }
+ }
+ return;
+ } else {
+ IMarker[] breakpoints= null;
+ try {
+ breakpoints= project.findMarkers(IDebugConstants.BREAKPOINT_MARKER, true, IResource.DEPTH_INFINITE);
+ } catch (CoreException e) {
+ logError(e);
+ return;
+ }
+ if (breakpoints != null) {
+ for (int i= 0; i < breakpoints.length; i++) {
+ try {
+ addBreakpoint(breakpoints[i]);
+ } catch (DebugException e) {
+ logError(e);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * @see IBreakpointManager.
+ */
+ public void setEnabled(IMarker marker, boolean enabled) throws CoreException {
+ marker.setAttribute(IDebugConstants.ENABLED, enabled);
+ }
+
+ /**
+ * Logs errors
+ */
+ protected void logError(Exception e) {
+ DebugCoreUtils.logError(e);
+ }
+
+ /**
+ * Visitor for handling resource deltas
+ */
+ class BreakpointManagerVisitor implements IResourceDeltaVisitor {
+ /**
+ * @see IResourceDeltaVisitor
+ */
+ public boolean visit(IResourceDelta delta) {
+ if (0 != (delta.getFlags() & IResourceDelta.OPEN)) {
+ handleProjectResourceOpenStateChange(delta.getResource());
+ return true;
+ }
+ IMarkerDelta[] markerDeltas= delta.getMarkerDeltas();
+ for (int i= 0; i < markerDeltas.length; i++) {
+ IMarkerDelta markerDelta= markerDeltas[i];
+ if (markerDelta.isSubtypeOf(IDebugConstants.BREAKPOINT_MARKER)) {
+ switch (markerDelta.getKind()) {
+ case IResourceDelta.ADDED :
+ handleAddBreakpoint(delta, markerDelta.getMarker(), markerDelta);
+ break;
+ case IResourceDelta.REMOVED :
+ handleRemoveBreakpoint(markerDelta.getMarker(), markerDelta);
+ break;
+ case IResourceDelta.CHANGED :
+ handleChangeBreakpoint(markerDelta.getMarker(), markerDelta);
+ break;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Wrapper for handling adds
+ */
+ protected void handleAddBreakpoint(IResourceDelta rDelta, final IMarker marker, IMarkerDelta mDelta) {
+ if (0 != (rDelta.getFlags() & IResourceDelta.MOVED_FROM)) {
+ // this breakpoint has actually been moved - removed from the Breakpoint manager and deleted
+ final IWorkspace workspace= getWorkspace();
+ final IWorkspaceRunnable wRunnable= new IWorkspaceRunnable() {
+ public void run(IProgressMonitor monitor) {
+ try {
+ marker.delete();
+ } catch (CoreException ce) {
+ logError(ce);
+ }
+ }
+ };
+ Runnable runnable= new Runnable() {
+ public void run() {
+ try {
+ workspace.run(wRunnable, null);
+ } catch (CoreException ce) {
+ logError(ce);
+ }
+ }
+ };
+ new Thread(runnable).start();
+ } else {
+ // do nothing - we do not add until explicitly added
+ }
+ }
+
+ /**
+ * Wrapper for handling removes
+ */
+ protected void handleRemoveBreakpoint(IMarker marker, IMarkerDelta delta) {
+ if (isRegistered(marker)) {
+ fBreakpoints.remove(marker);
+ fireUpdate(marker, delta, REMOVED);
+ }
+ }
+
+ /**
+ * Wrapper for handling changes
+ */
+ protected void handleChangeBreakpoint(IMarker marker, IMarkerDelta delta) {
+ if (isRegistered(marker)) {
+ fireUpdate(marker, delta, CHANGED);
+ }
+ }
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public void addBreakpointListener(IBreakpointListener listener) {
+ fBreakpointListeners.add(listener);
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public void removeBreakpointListener(IBreakpointListener listener) {
+ fBreakpointListeners.remove(listener);
+ }
+
+ /**
+ * Notifies listeners of the add/remove/change
+ */
+ protected void fireUpdate(IMarker marker, IMarkerDelta delta, int update) {
+ Object[] copiedListeners= fBreakpointListeners.getListeners();
+ for (int i= 0; i < copiedListeners.length; i++) {
+ IBreakpointListener listener = (IBreakpointListener)copiedListeners[i];
+ if (supportsBreakpoint(listener, marker)) {
+ switch (update) {
+ case ADDED:
+ listener.breakpointAdded(marker);
+ break;
+ case REMOVED:
+ listener.breakpointRemoved(marker, delta);
+ break;
+ case CHANGED:
+ listener.breakpointChanged(marker, delta);
+ break;
+ }
+
+ }
+ }
+ }
+
+ /**
+ * Returns whether the given listener supports breakpoints. If
+ * the listener is a debug target, we check if the specific
+ * breakpoint is supported by the target.
+ */
+ protected boolean supportsBreakpoint(IBreakpointListener listener, IMarker breakpoint) {
+ if (listener instanceof IBreakpointSupport) {
+ return ((IBreakpointSupport)listener).supportsBreakpoint(breakpoint);
+ } else {
+ return true;
+ }
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public void configureBreakpoint(IMarker breakpoint, String modelIdentifier, boolean enabled) throws CoreException {
+ breakpoint.setAttributes(fgBreakpointAttributes, new Object[]{modelIdentifier, new Boolean(enabled)});
+ }
+
+ /**
+ * @see IBreakpointManager
+ */
+ public void configureLineBreakpoint(IMarker breakpoint, String modelIdentifier, boolean enabled, int lineNumber, int charStart, int charEnd) throws CoreException {
+ Object[] values= new Object[]{modelIdentifier, new Boolean(enabled), new Integer(lineNumber), new Integer(charStart), new Integer(charEnd)};
+ breakpoint.setAttributes(fgLineBreakpointAttributes, values);
+ }
+
+ /**
+ * Adds any debug targets as listeners
+ *
+ * @see ILaunchListener
+ */
+ public void launchRegistered(ILaunch launch) {
+ IDebugTarget dt= launch.getDebugTarget();
+ if (dt != null) {
+ addBreakpointListener(dt);
+ }
+ }
+
+ /**
+ * Removes the debug target associated with
+ * this launch as a breakpoint listener.
+ *
+ * @see ILaunchListener
+ */
+ public void launchDeregistered(ILaunch launch) {
+ IDebugTarget dt= launch.getDebugTarget();
+ if (dt != null) {
+ removeBreakpointListener(dt);
+ }
+ }
+}
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugCoreResources.properties b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugCoreResources.properties
new file mode 100644
index 000000000..9c9d00790
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugCoreResources.properties
@@ -0,0 +1,55 @@
+##############################################################
+# Licensed Materials - Property of IBM,
+# WebSphere Studio Workbench
+# (c) Copyright IBM Corp 2001
+##############################################################
+
+##############################################################
+# BreakpointManager
+##############################################################
+breakpoint_manager.error.adapter=IDesktopElement adapter required to set a breakpoint.
+breakpoint_manager.error.label_property=Label property required to set a breakpoint.
+breakpoint_manager.error.extension=File extension required to set a breakpoint.
+breakpoint_manager.error.associated_resource=Breakpoint creator did not specify associated resource.
+breakpoint_manager.error.required_attributes= Breakpoint creator did not configure required attributes.
+breakpoint_manager.error.line_number=Breakpoint already exists at line number {0}.
+breakpoint_manager.error.creation_failed=Breakpoint creation failed.
+breakpoint_manager.error.unsupported_extension=Unsupported file extension {0}.
+breakpoint_manager.error.installation_failed=Breakpoint installation failed - attempt to re-install breakpoint.
+breakpoint_manager.error.remove_failed=Breakpoint remove failed.
+breakpoint_manager.error.enable=Attempt to enable breakpoint that does not exist.
+breakpoint_manager.error.hitcount=Attempt to set hit count on a breakpoint that does not exist.
+breakpoint_manager.error.target=Debug target breakpoint set failed.
+
+##############################################################
+# ExceptionManager
+##############################################################
+exception_manager.error.state=Illegal value for exception state.
+exception_manager.error.duplicate=Failed to create exception - it already exists.
+exception_manager.error.persisting=Error persisting exceptions.
+exception_manager.error.restoring=Error restoring exceptions.
+
+##############################################################
+# InputStreamMonitor
+##############################################################
+input_stream_monitor.label=Input Stream Monitor
+
+##############################################################
+# LaunchManager
+##############################################################
+launch_manager.error.termination=Unable to terminate launch.
+
+##############################################################
+# ProcessMonitor
+##############################################################
+process_monitor.label=Process Monitor
+
+##############################################################
+# SourceLocation
+##############################################################
+source_location.undetermined=undetermined
+
+##############################################################
+# TargetException
+##############################################################
+target_exception.error.state=Illegal value for exception state \ No newline at end of file
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugCoreUtils.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugCoreUtils.java
new file mode 100644
index 000000000..83fd4f8e7
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/DebugCoreUtils.java
@@ -0,0 +1,58 @@
+package org.eclipse.debug.internal.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2001
+ */
+
+import org.eclipse.debug.core.DebugPlugin;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+/**
+ * Utility methods for the debug core plugin.
+ */
+public class DebugCoreUtils {
+
+ private static ResourceBundle fgResourceBundle;
+
+ /**
+ * Utility method
+ */
+ public static String getResourceString(String key) {
+ if (fgResourceBundle == null) {
+ fgResourceBundle= getResourceBundle();
+ }
+ if (fgResourceBundle != null) {
+ return fgResourceBundle.getString(key);
+ } else {
+ return "!" + key + "!";
+ }
+ }
+
+ /**
+ * Returns the resource bundle used by the core debug plugin.
+ */
+ public static ResourceBundle getResourceBundle() {
+ try {
+ return ResourceBundle.getBundle("org.eclipse.debug.internal.core.DebugCoreResources");
+ } catch (MissingResourceException e) {
+ logError(e);
+ }
+ return null;
+ }
+
+ /**
+ * Convenience method to log internal errors
+ */
+ public static void logError(Exception e) {
+ if (DebugPlugin.getDefault().isDebugging()) {
+ // this message is intentionally not internationalized, as an exception may
+ // be due to the resource bundle itself
+ System.out.println("Internal error logged from debug core: ");
+ e.printStackTrace();
+ System.out.println();
+ }
+ }
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/InputStreamMonitor.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/InputStreamMonitor.java
new file mode 100644
index 000000000..772af46e6
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/InputStreamMonitor.java
@@ -0,0 +1,160 @@
+package org.eclipse.debug.internal.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.IStreamListener;
+import org.eclipse.debug.core.model.IStreamMonitor;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Monitors an input stream (connected to the output stream of
+ * a system process). An notifies listeners of additions to the
+ * stream.
+ *
+ * @see IStreamMonitor
+ */
+public class InputStreamMonitor implements IStreamMonitor {
+
+ private final static String PREFIX= "input_stream_monitor.";
+ private final static String LABEL= PREFIX + "label";
+
+ /**
+ * The input stream being monitored.
+ */
+ protected InputStream fStream;
+
+ /**
+ * A collection of listeners
+ */
+ protected ListenerList fListeners= new ListenerList(1);
+
+ /**
+ * The local copy of the stream contents
+ */
+ protected StringBuffer fContents;
+
+ /**
+ * The thread which reads from the stream
+ */
+ protected Thread fThread;
+
+ /**
+ * The size of the read buffer
+ */
+ protected static final int BUFFER_SIZE= 8192;
+
+ /**
+ * The number of milliseconds to pause
+ * between reads.
+ */
+ protected static final long DELAY= 50L;
+ /**
+ * Creates an input stream monitor on the
+ * given input stream.
+ */
+ public InputStreamMonitor(InputStream stream) {
+ fStream= stream;
+ fContents= new StringBuffer();
+ }
+
+ /**
+ * @see IStreamMonitor
+ */
+ public void addListener(IStreamListener listener) {
+ fListeners.add(listener);
+ }
+
+ /**
+ * Causes the monitor to close all
+ * communications between it and the
+ * underlying stream.
+ */
+ public void close() {
+ if (fThread != null) {
+ Thread thread= fThread;
+ fThread= null;
+ try {
+ thread.join();
+ } catch (InterruptedException ie) {
+ }
+ }
+ }
+
+ /**
+ * Notifies the listeners that text has
+ * been appended to the stream.
+ */
+ public void fireStreamAppended(String text) {
+ if (text == null)
+ return;
+ Object[] copiedListeners= fListeners.getListeners();
+ for (int i= 0; i < copiedListeners.length; i++) {
+ ((IStreamListener) copiedListeners[i]).streamAppended(text, this);
+ }
+ }
+
+ /**
+ * @see IStreamMonitor
+ */
+ public String getContents() {
+ return fContents.toString();
+ }
+
+ /**
+ * Continually reads from the stream.
+ * <p>
+ * This method, along with the <code>startReading</code>
+ * method is used to allow <code>InputStreamMonitor</code>
+ * to implement <code>Runnable</code> without publicly
+ * exposing a <code>run</code> method.
+ */
+ private void read() {
+ byte[] bytes= new byte[BUFFER_SIZE];
+ while (true) {
+ try {
+ if (fStream.available() == 0) {
+ if (fThread == null)
+ break;
+ } else {
+ int read= fStream.read(bytes);
+ if (read > 0) {
+ String text= new String(bytes, 0, read);
+ fContents.append(text);
+ fireStreamAppended(text);
+ }
+ }
+ } catch (IOException ioe) {
+ }
+ try {
+ Thread.sleep(DELAY);
+ } catch (InterruptedException ie) {
+ }
+ }
+ }
+
+ /**
+ * @see IStreamMonitor
+ */
+ public void removeListener(IStreamListener listener) {
+ fListeners.remove(listener);
+ }
+
+ /**
+ * Starts a <code>Thread</code> which reads the stream.
+ */
+ public void startMonitoring() {
+ if (fThread == null) {
+ fThread= new Thread(new Runnable() {
+ public void run() {
+ read();
+ }
+ }, DebugCoreUtils.getResourceString(LABEL));
+ fThread.start();
+ }
+ }
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/LaunchManager.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/LaunchManager.java
new file mode 100644
index 000000000..327427c39
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/LaunchManager.java
@@ -0,0 +1,241 @@
+package org.eclipse.debug.internal.core;
+
+/*
+* Licensed Materials - Property of IBM,
+* WebSphere Studio Workbench
+* (c) Copyright IBM Corp 2000
+*/
+
+import org.eclipse.debug.core.*;
+import org.eclipse.debug.core.model.IDebugTarget;
+import org.eclipse.debug.core.model.IProcess;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.*;
+import java.util.*;
+
+/**
+ * Manages registered launches.
+ *
+ * @see ILaunchManager
+ */
+public class LaunchManager extends PlatformObject implements ILaunchManager {
+
+ private final static String PREFIX= "launch_manager.";
+ private final static String ERROR= PREFIX + "error.";
+ private final static String TERMINATION= ERROR + "termination";
+
+ /**
+ * Constant for use as local name part of <code>QualifiedName</code>
+ * for persisting the default launcher.
+ */
+ private static final String DEFAULT_LAUNCHER= "launcher";
+
+ /**
+ * Types of notifications
+ */
+ private static final int REGISTERED = 0;
+ private static final int DEREGISTERED = 1;
+
+ /**
+ * Collection of launches
+ */
+ protected Vector fLaunches= new Vector(10);
+
+ /**
+ * Collection of listeners
+ */
+ protected ListenerList fListeners= new ListenerList(5);
+
+ /**
+ * @see ILaunchManager
+ */
+ public void addLaunchListener(ILaunchListener listener) {
+ fListeners.add(listener);
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public void deregisterLaunch(ILaunch launch) {
+ fLaunches.remove(launch);
+ fireUpdate(launch, DEREGISTERED);
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public ILaunch findLaunch(IProcess process) {
+ Iterator list= fLaunches.iterator();
+ while (list.hasNext()) {
+ ILaunch l= (ILaunch) list.next();
+ IProcess[] ps= l.getProcesses();
+ for (int i= 0; i < ps.length; i++) {
+ if (ps[i].equals(process)) {
+ return l;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public ILaunch findLaunch(IDebugTarget target) {
+ Iterator list= fLaunches.iterator();
+ while (list.hasNext()) {
+ ILaunch l= (ILaunch) list.next();
+ if (target.equals(l.getDebugTarget())) {
+ return l;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Fires notification to the listeners that a launch has been (de)registered.
+ */
+ public void fireUpdate(ILaunch launch, int update) {
+ Object[] copiedListeners= fListeners.getListeners();
+ for (int i= 0; i < copiedListeners.length; i++) {
+ ILaunchListener listener = (ILaunchListener)copiedListeners[i];
+ switch (update) {
+ case REGISTERED:
+ listener.launchRegistered(launch);
+ break;
+ case DEREGISTERED:
+ listener.launchDeregistered(launch);
+ break;
+ }
+ }
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public IDebugTarget[] getDebugTargets() {
+ List targets= new ArrayList(fLaunches.size());
+ if (fLaunches.size() > 0) {
+ Iterator e= fLaunches.iterator();
+ while (e.hasNext()) {
+ IDebugTarget target= ((ILaunch) e.next()).getDebugTarget();
+ if (target != null)
+ targets.add(target);
+ }
+ }
+ return (IDebugTarget[])targets.toArray(new IDebugTarget[targets.size()]);
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public ILauncher getDefaultLauncher(IProject project) throws CoreException {
+ ILauncher launcher= null;
+ if ((project != null) && project.isOpen()) {
+ String launcherID = project.getPersistentProperty(new QualifiedName(IDebugConstants.PLUGIN_ID, DEFAULT_LAUNCHER));
+ if (launcherID != null) {
+ launcher= getLauncher(launcherID);
+ }
+ }
+ return launcher;
+ }
+
+ /**
+ * Returns the launcher with the given id, or <code>null</code>.
+ */
+ public ILauncher getLauncher(String id) {
+ ILauncher[] launchers= getLaunchers();
+ for (int i= 0; i < launchers.length; i++) {
+ if (launchers[i].getIdentifier().equals(id)) {
+ return launchers[i];
+ }
+ }
+ return null;
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public ILauncher[] getLaunchers() {
+ return DebugPlugin.getDefault().getLaunchers();
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public ILauncher[] getLaunchers(String mode) {
+ ILauncher[] launchers = getLaunchers();
+ ArrayList list = new ArrayList();
+ for (int i = 0; i < launchers.length; i++) {
+ if (launchers[i].getModes().contains(mode)) {
+ list.add(launchers[i]);
+ }
+ }
+ return (ILauncher[])list.toArray(new ILauncher[list.size()]);
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public ILaunch[] getLaunches() {
+ return (ILaunch[])fLaunches.toArray(new ILaunch[fLaunches.size()]);
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public IProcess[] getProcesses() {
+ List allProcesses= new ArrayList(fLaunches.size());
+ if (fLaunches.size() > 0) {
+ Iterator e= fLaunches.iterator();
+ while (e.hasNext()) {
+ IProcess[] processes= ((ILaunch) e.next()).getProcesses();
+ for (int i= 0; i < processes.length; i++) {
+ allProcesses.add(processes[i]);
+ }
+ }
+ }
+ return (IProcess[])allProcesses.toArray(new IProcess[allProcesses.size()]);
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public void registerLaunch(ILaunch launch) {
+ fLaunches.add(launch);
+ fireUpdate(launch, REGISTERED);
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public void removeLaunchListener(ILaunchListener listener) {
+ fListeners.remove(listener);
+ }
+
+ /**
+ * @see ILaunchManager
+ */
+ public void setDefaultLauncher(IProject resource, ILauncher launcher) throws CoreException {
+ String id = null;
+ if (launcher != null) {
+ id = launcher.getIdentifier();
+ }
+ resource.setPersistentProperty(new QualifiedName(IDebugConstants.PLUGIN_ID, DEFAULT_LAUNCHER), id);
+ }
+
+ /**
+ * Terminates/Disconnects any active debug targets/processes.
+ */
+ public void shutdown() {
+ ILaunch[] launches = getLaunches();
+ for (int i= 0; i < launches.length; i++) {
+ ILaunch launch= launches[i];
+ try {
+ launch.terminate();
+ } catch (DebugException e) {
+ DebugCoreUtils.logError(e);
+ }
+ }
+ }
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/Launcher.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/Launcher.java
new file mode 100644
index 000000000..50d444e98
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/Launcher.java
@@ -0,0 +1,113 @@
+package org.eclipse.debug.internal.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.ILauncher;
+import org.eclipse.debug.core.model.ILauncherDelegate;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.StringTokenizer;
+
+/**
+ * A handle to a launcher extension that instantiates the actual
+ * extension lazily.
+ */
+public class Launcher implements ILauncher {
+
+ /**
+ * The configuration element that defines this launcher handle
+ */
+ protected IConfigurationElement fConfigElement = null;
+
+ /**
+ * The underlying launcher, which is <code>null</code> until the
+ * it needs to be instantiated.
+ */
+ protected ILauncherDelegate fDelegate = null;
+
+ /**
+ * Cache of the modes this launcher supports
+ */
+ protected Set fModes;
+
+ /**
+ * Constructs a handle for a launcher extension.
+ */
+ public Launcher(IConfigurationElement element) {
+ fConfigElement = element;
+ }
+
+ /**
+ * @see ILauncher
+ */
+ public String getIdentifier() {
+ return fConfigElement.getAttribute("id");
+ }
+
+ /**
+ * Returns the set of modes specified in the configuration data.
+ * The set contains "mode" constants defined in <code>ILaunchManager</code>
+ */
+ public Set getModes() {
+ if (fModes == null) {
+ String modes= fConfigElement.getAttribute("modes");
+ if (modes == null) {
+ return null;
+ }
+ StringTokenizer tokenizer= new StringTokenizer(modes, ",");
+ fModes = new HashSet(tokenizer.countTokens());
+ while (tokenizer.hasMoreTokens()) {
+ fModes.add(tokenizer.nextToken().trim());
+ }
+ }
+ return fModes;
+ }
+
+ /**
+ * Returns the label specified in the configuration data.
+ */
+ public String getLabel() {
+ return fConfigElement.getAttribute("label");
+ }
+
+ /**
+ * @see ILauncher
+ */
+ public String getPerspectiveIdentifier() {
+ return fConfigElement.getAttribute("perspective");
+ }
+
+ /**
+ * Returns the launcher for this handle, instantiating it if required.
+ */
+ public ILauncherDelegate getDelegate() {
+ if (fDelegate == null) {
+ try {
+ fDelegate = (ILauncherDelegate)fConfigElement.createExecutableExtension("class");
+ } catch (CoreException e) {
+ //status logged in the #createExecutableExtension code
+ }
+ }
+ return fDelegate;
+ }
+
+ /**
+ * @see ILauncher
+ */
+ public boolean launch(Object[] elements, String mode) {
+ return getDelegate().launch(elements, mode, this);
+ }
+
+ /**
+ * Returns the configuration element for this extension
+ */
+ public IConfigurationElement getConfigurationElement() {
+ return fConfigElement;
+ }
+} \ No newline at end of file
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/ListenerList.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/ListenerList.java
new file mode 100644
index 000000000..c6e274d91
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/ListenerList.java
@@ -0,0 +1,142 @@
+package org.eclipse.debug.internal.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2001
+ */
+
+/**
+ * Local version of org.eclipse.jface.util.ListenerList
+ */
+public class ListenerList {
+ /**
+ * The initial capacity of the list. Always >= 1.
+ */
+ private int fCapacity;
+
+ /**
+ * The current number of listeners.
+ * Maintains invariant: 0 <= fSize <= listeners.length.
+ */
+ private int fSize;
+
+ /**
+ * The list of listeners. Initially <code>null</code> but initialized
+ * to an array of size capacity the first time a listener is added.
+ * Maintains invariant: listeners != null IFF fSize != 0
+ */
+ private Object[] fListeners= null;
+
+ /**
+ * The empty array singleton instance, returned by getListeners()
+ * when size == 0.
+ */
+ private static final Object[] EmptyArray= new Object[0];
+ /**
+ * Creates a listener list with an initial capacity of 3.
+ */
+ public ListenerList() {
+ this(3);
+ }
+
+ /**
+ * Creates a listener list with the given initial capacity.
+ *
+ * @param capacity the number of listeners which this list can initially accept
+ * without growing its internal representation; must be at least 1
+ */
+ public ListenerList(int capacity) {
+ if (capacity < 1) {
+ throw new IllegalArgumentException();
+ }
+ fCapacity= capacity;
+ }
+
+ /**
+ * Adds a listener to the list.
+ * Has no effect if an identical listener is already registered.
+ *
+ * @param listener a listener
+ */
+ public void add(Object listener) {
+ if (listener == null) {
+ throw new IllegalArgumentException();
+ }
+ if (fSize == 0) {
+ fListeners= new Object[fCapacity];
+ } else {
+ // check for duplicates using identity
+ for (int i= 0; i < fSize; ++i) {
+ if (fListeners[i] == listener) {
+ return;
+ }
+ }
+ // grow array if necessary
+ if (fSize == fListeners.length) {
+ System.arraycopy(fListeners, 0, fListeners= new Object[fSize * 2 + 1], 0, fSize);
+ }
+ }
+ fListeners[fSize++]= listener;
+ }
+
+ /**
+ * Returns an array containing all the registered listeners.
+ * The resulting array is unaffected by subsequent adds or removes.
+ * If there are no listeners registered, the result is an empty array
+ * singleton instance (no garbage is created).
+ * Use this method when notifying listeners, so that any modifications
+ * to the listener list during the notification will have no effect on the
+ * notification itself.
+ */
+ public Object[] getListeners() {
+ if (fSize == 0)
+ return EmptyArray;
+ Object[] result= new Object[fSize];
+ System.arraycopy(fListeners, 0, result, 0, fSize);
+ return result;
+ }
+
+ /**
+ * Returns <code>true</code> if there are no registered listeners,
+ * <code>false</code> otherwise.
+ */
+ public boolean isEmpty() {
+ return fSize == 0;
+ }
+
+ /**
+ * Removes a listener from the list.
+ * Has no effect if an identical listener was not already registered.
+ *
+ * @param listener a listener
+ */
+ public void remove(Object listener) {
+ if (listener == null) {
+ throw new IllegalArgumentException();
+ }
+
+ for (int i= 0; i < fSize; ++i) {
+ if (fListeners[i] == listener) {
+ if (fSize == 1) {
+ fListeners= null;
+ fSize= 0;
+ } else {
+ System.arraycopy(fListeners, i + 1, fListeners, i, --fSize - i);
+ fListeners[fSize]= null;
+ }
+ return;
+ }
+ }
+ }
+
+ /**
+ * Returns the number of registered listeners
+ *
+ * @return the number of registered listeners
+ */
+ public int size() {
+ return fSize;
+ }
+}
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/ProcessMonitor.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/ProcessMonitor.java
new file mode 100644
index 000000000..fe42eaff2
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/ProcessMonitor.java
@@ -0,0 +1,72 @@
+package org.eclipse.debug.internal.core;
+
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.*;
+
+/**
+ * Monitors a system process, wiating for it to terminate, and
+ * then notifies the associated runtime process.
+ */
+
+public class ProcessMonitor {
+
+ private final static String PREFIX= "process_monitor.";
+ private final static String LABEL= PREFIX + "label";
+ /**
+ * The <code>IProcess</code> being monitored.
+ */
+ protected RuntimeProcess fProcess;
+ /**
+ * The <code>java.lang.Process</code> being monitored.
+ */
+ protected Process fOSProcess;
+ /**
+ * The <code>Thread</code> which is monitoring the process.
+ */
+ protected Thread fThread;
+ /**
+ * Creates a new process monitor and starts monitoring the process
+ * for termination.
+ */
+ public ProcessMonitor(RuntimeProcess process) {
+ fProcess= process;
+ fOSProcess= process.getSystemProcess();
+ startMonitoring();
+ }
+
+ /**
+ * Monitors the process for termination
+ */
+ private void monitorProcess() {
+ while (fOSProcess != null) {
+ try {
+ fOSProcess.waitFor();
+ fOSProcess= null;
+ fProcess.terminated();
+ } catch (InterruptedException ie) {
+ }
+ }
+ }
+
+ /**
+ * Starts monitoring the process to determine
+ * if it has terminated.
+ */
+ private void startMonitoring() {
+ if (fThread == null) {
+ fThread= new Thread(new Runnable() {
+ public void run() {
+ monitorProcess();
+ }
+ }, DebugCoreUtils.getResourceString(LABEL));
+ fThread.start();
+ }
+ }
+
+}
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/RuntimeProcess.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/RuntimeProcess.java
new file mode 100644
index 000000000..8cc813979
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/RuntimeProcess.java
@@ -0,0 +1,202 @@
+package org.eclipse.debug.internal.core;
+
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.*;
+import org.eclipse.debug.core.model.IProcess;
+import org.eclipse.debug.core.model.IStreamsProxy;
+import org.eclipse.core.runtime.PlatformObject;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashMap;
+
+
+/**
+ * A runtime process is a wrapper for a non-debuggable
+ * system process. The process will appear in the debug UI with
+ * console and termination support. The process creates a streams
+ * proxy for itself, and a process monitor that monitors the
+ * underlying system process for terminataion.
+ */
+public class RuntimeProcess extends PlatformObject implements IProcess {
+ /**
+ * The system process
+ */
+ protected Process fProcess;
+
+ /**
+ * Process monitor
+ */
+ protected ProcessMonitor fMonitor;
+
+ /**
+ * The streams proxy for this process
+ */
+ protected StreamsProxy fStreamsProxy;
+
+ /**
+ * The name of the process
+ */
+ protected String fName;
+
+ /**
+ * <code>true</code> when this process has been termianted
+ */
+ protected boolean fTerminated;
+
+ /**
+ * Table of cleint defined attributes
+ */
+ protected HashMap fAttributes;
+
+ /**
+ * Constructs a RuntimeProcess on the given system process
+ * with the given name.
+ */
+ public RuntimeProcess(Process process, String name) {
+ fProcess= process;
+ fName= name;
+ fTerminated= true;
+ try {
+ process.exitValue();
+ } catch (IllegalThreadStateException e) {
+ fTerminated= false;
+ }
+ fMonitor = new ProcessMonitor(this);
+ fStreamsProxy = new StreamsProxy(this);
+ fireCreationEvent();
+ }
+
+ /**
+ * @see IProcess
+ */
+ public boolean canTerminate() {
+ return !fTerminated;
+ }
+
+ /**
+ * Returns the error stream of the underlying system process (connected
+ * to the standard error of the process).
+ */
+ public InputStream getErrorStream() {
+ return fProcess.getErrorStream();
+ }
+
+ /**
+ * Returns the input stream of the underlying system process (connected
+ * to the standard out of the process).
+ */
+ public InputStream getInputStream() {
+ return fProcess.getInputStream();
+ }
+
+ /**
+ * @see IProcess
+ */
+ public String getLabel() {
+ return fName;
+ }
+
+ /**
+ * @see IProcess
+ */
+ public ILaunch getLaunch() {
+ return DebugPlugin.getDefault().getLaunchManager().findLaunch(this);
+ }
+
+ /**
+ * Returns the output stream of the underlying system process (connected
+ * to the standard in of the process).
+ */
+ public OutputStream getOutputStream() {
+ return fProcess.getOutputStream();
+ }
+
+ public Process getSystemProcess() {
+ return fProcess;
+ }
+
+ /**
+ * @see IProcess
+ */
+ public boolean isTerminated() {
+ return fTerminated;
+ }
+
+ /**
+ * @see IProcess
+ */
+ public void terminate() throws DebugException {
+ if (!isTerminated()) {
+ fProcess.destroy();
+ try {
+ fProcess.waitFor();
+ } catch (InterruptedException ie) {}
+ }
+ }
+
+ /**
+ * Notification that the system process associated with this process
+ * has terminated.
+ */
+ public void terminated() {
+ fStreamsProxy.close();
+ fTerminated= true;
+ fProcess= null;
+ fireTerminateEvent();
+ }
+
+ public IStreamsProxy getStreamsProxy() {
+ return fStreamsProxy;
+ }
+
+ /**
+ * Fire a debug event marking the creation of this element.
+ */
+ public void fireCreationEvent() {
+ fireEvent(new DebugEvent(this, DebugEvent.CREATE));
+ }
+
+ /**
+ * Fire a debug event
+ */
+ public void fireEvent(DebugEvent event) {
+ DebugPlugin manager= DebugPlugin.getDefault();
+ if (manager != null) {
+ manager.fireDebugEvent(event);
+ }
+ }
+
+ /**
+ * Fire a debug event marking the termination of this process.
+ */
+ public void fireTerminateEvent() {
+ fireEvent(new DebugEvent(this, DebugEvent.TERMINATE));
+ }
+
+ /**
+ * @see IProcess
+ */
+ public void setAttribute(String key, String value) {
+ if (fAttributes == null) {
+ fAttributes = new HashMap(5);
+ }
+ fAttributes.put(key, value);
+ }
+
+ /**
+ * @see IProcess
+ */
+ public String getAttribute(String key) {
+ if (fAttributes == null) {
+ return null;
+ }
+ return (String)fAttributes.get(key);
+ }
+}
+
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/StreamsProxy.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/StreamsProxy.java
new file mode 100644
index 000000000..919069061
--- /dev/null
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/StreamsProxy.java
@@ -0,0 +1,86 @@
+package org.eclipse.debug.internal.core;
+
+/*
+ * Licensed Materials - Property of IBM,
+ * WebSphere Studio Workbench
+ * (c) Copyright IBM Corp 2000
+ */
+
+import org.eclipse.debug.core.model.IStreamMonitor;
+import org.eclipse.debug.core.model.IStreamsProxy;
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * @see IStreamsProxy
+ */
+public class StreamsProxy implements IStreamsProxy {
+ /**
+ * The monitor for the input stream (connected to standard out of the process)
+ */
+ protected InputStreamMonitor fInputMonitor;
+ /**
+ * The monitor for the error stream.
+ */
+ protected InputStreamMonitor fErrorMonitor;
+ /**
+ * The <code>OutputStream</code> of the <code>IProcess</code>.
+ */
+ protected OutputStream fOutputStream;
+ /**
+ * Records the open/closed state of communications with
+ * the underlying streams.
+ */
+ protected boolean fClosed= false;
+ /**
+ * Creates a <code>StreamsProxy</code> on the streams
+ * of the given <code>IProcess</code>.
+ */
+ public StreamsProxy(RuntimeProcess process) {
+ if (process != null) {
+ fInputMonitor= new InputStreamMonitor(process.getInputStream());
+ fErrorMonitor= new InputStreamMonitor(process.getErrorStream());
+ fOutputStream= process.getOutputStream();
+ fInputMonitor.startMonitoring();
+ fErrorMonitor.startMonitoring();
+ }
+ }
+
+ /**
+ * Causes the proxy to close all
+ * communications between it and the
+ * underlying streams.
+ */
+ public void close() {
+ fClosed= true;
+ fInputMonitor.close();
+ fErrorMonitor.close();
+ }
+
+ /**
+ * @see IStreamsProxy
+ */
+ public IStreamMonitor getErrorStreamMonitor() {
+ return fErrorMonitor;
+ }
+
+ /**
+ * @see IStreamsProxy
+ */
+ public IStreamMonitor getOutputStreamMonitor() {
+ return fInputMonitor;
+ }
+
+ /**
+ * @see IStreamsProxy
+ */
+ public void write(String input) throws IOException {
+ if (!fClosed && fOutputStream != null) {
+ fOutputStream.write(input.getBytes());
+ fOutputStream.flush();
+ } else {
+ throw new IOException();
+ }
+ }
+
+}
diff --git a/org.eclipse.debug.core/doc/hglegal.htm b/org.eclipse.debug.core/doc/hglegal.htm
new file mode 100644
index 000000000..5ac1c6333
--- /dev/null
+++ b/org.eclipse.debug.core/doc/hglegal.htm
@@ -0,0 +1,19 @@
+<!doctype html public "-//w3c//dtd html 3.2 final//en">
+<html>
+
+<head>
+<title>Legal Notices</title>
+</head>
+
+<body>
+
+<h3><a name="Notices">Notices</a></h3>
+
+<p>Licensed Materials - Property of IBM<br>
+WebSphere Studio Workbench<br>
+(c) Copyright IBM Corp. 2000 All Rights Reserved.</p>
+
+<p>US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+GSA ADP Schedule Contract with IBM Corp.</p>
+</body>
+</html>
diff --git a/org.eclipse.debug.core/doc/ngibmcpy.gif b/org.eclipse.debug.core/doc/ngibmcpy.gif
new file mode 100644
index 000000000..e0d777bf5
--- /dev/null
+++ b/org.eclipse.debug.core/doc/ngibmcpy.gif
Binary files differ
diff --git a/org.eclipse.debug.core/doc/org_eclipse_debug_core.html b/org.eclipse.debug.core/doc/org_eclipse_debug_core.html
new file mode 100644
index 000000000..eec9824c6
--- /dev/null
+++ b/org.eclipse.debug.core/doc/org_eclipse_debug_core.html
@@ -0,0 +1,36 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<meta name="GENERATOR" content="Microsoft FrontPage 3.0">
+<title>README Debug User Interface Extension Points</title>
+</head>
+
+<body link="#0000FF" vlink="#800080">
+
+<h1 align="center">Eclipse Debug Tools Infrastructure</h1>
+
+<p>The debug tools infrastructure plug-in, <font face="Courier">org.eclipse.debug.core</font>,
+defines a model for language independent debugging. A set of common debug artifacts and
+actions are defined by interfaces, for which specific debug architectures may provide
+implementations. For example, some common artifacts are threads, stack frames, and
+variables; some common actions are terminate, suspend, step, and resume. A debug
+architecture, such as JDI (Java Debug Interface), can provide an implementation of the
+artifacts and actions. The debug plug-in also defines and provides an implementation of
+managers to support breakpoints and launching.<br>
+</p>
+
+<hr>
+
+<h1>Extension Points</h1>
+
+<p>The following extension points are used to support and extend the debug infrastructure:
+
+<ul>
+ <li><a href="org_eclipse_debug_core_launchers.html">org.eclipse.debug.core.launchers</a></li>
+</ul>
+
+<p><a href="hglegal.htm"><img src="ngibmcpy.gif" alt="Copyright IBM Corporation 2000"
+border="0" width="195" height="12"></a></p>
+</body>
+</html>
diff --git a/org.eclipse.debug.core/doc/org_eclipse_debug_core_launchers.html b/org.eclipse.debug.core/doc/org_eclipse_debug_core_launchers.html
new file mode 100644
index 000000000..2efde17b0
--- /dev/null
+++ b/org.eclipse.debug.core/doc/org_eclipse_debug_core_launchers.html
@@ -0,0 +1,95 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<meta name="GENERATOR" content="Microsoft FrontPage 3.0">
+<title>README Launcher Extension Points</title>
+</head>
+
+<body link="#0000FF" vlink="#800080">
+
+<h1 align="center">Launcher</h1>
+
+<p><b><i>Identifier: </i></b>org.eclipse.debug.core.launchers </p>
+
+<p><b><i>Description: </i></b>This extension point allows tools to contribute launchers. A
+launcher is responsible for initiating a debug session or running a program and
+registering the result with the launch manager.</p>
+
+<p><b><i>Configuration Markup:</i></b> </p>
+
+<pre><tt>&nbsp;&nbsp; &lt;!ATTLIST launcher</tt>
+ id CDATA #REQUIRED<tt>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; class CDATA #REQUIRED</tt>
+<tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; modes CDATA #REQUIRED
+</tt> label CDATA #REQUIRED
+ wizard CDATA #IMPLIED
+ public CDATA #IMPLIED
+ description CDATA #IMPLIED
+ <tt>perspective CDATA #IMPLIED
+ &gt;</tt> </pre>
+
+<ul>
+ <li><strong>id </strong>&#150; a unique identifier that can be used to reference this
+ launcher.</li>
+ <li><b>class</b> &#150; fully qualified name of the class that implements <font
+ face="Courier New">org.eclipse.debug.core.ILauncherDelegate</font>.</li>
+ <li><b>modes</b> &#150; A comma separated list of modes this launcher supports. The two
+ supported modes are &quot;run&quot; and &quot;debug&quot; - as defined in <font
+ face="Courier New">org.eclipse.debug.core.ILaunchManager.</font>A launcher may be capable
+ of launching in one or both modes.</li>
+ <li><strong>label </strong>&#150; a label to use for the launcher. This attribute is used by
+ the debug UI.</li>
+ <li><strong>wizard </strong>&#150; fully qualified name of the class that implements <font
+ face="Courier New">org.eclipse.debug.ui.ILaunchWizard</font>. This attribute is used by
+ the debug UI. A launcher may contribute a wizard that allows users to configure and launch
+ specific attributes.</li>
+ <li><strong>public</strong> &#150; whether a launcher is publically visible in the debug UI.
+ &nbsp; If &quot;true&quot;,&nbsp; the launcher will be available from the debug UI - the
+ launcher will appear as a choice for a default launcher, launches created by this launcher
+ will appear in the launch history, and the launcher will be available from the drop-down
+ run/debug toolbar actions.</li>
+ <li><strong>description</strong> &#150; a description of the launcher.&nbsp; Currently only
+ used if the <em>wizard</em> attribute is specified.</li>
+ <li><strong>perspective</strong> &#150; the identifier of the perspective that will be
+ switched to on a successful launch.&nbsp; Default value is the identifier for the debug
+ perspective. This attribute is used by the debug UI.</li>
+</ul>
+
+<p><b><i>Examples:</i></b> </p>
+
+<p>The following is an example of a launcher extension point: </p>
+
+<pre><tt>&nbsp;&nbsp; &lt;extension</tt>
+<tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; point = &quot;org.eclipse.debug.core.launchers&quot;&gt;</tt>
+<tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;launcher</tt>
+ id = &quot;com.example.ExampleLauncher&quot;
+<tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; class = &quot;com.example.launchers.ExampleLauncher&quot;</tt>
+<tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; modes = &quot;run, debug&quot;
+ label = &quot;Example Launcher&quot;
+ wizard = &quot;com.example.launchers.ui.ExampleLaunchWizard&quot;
+ public = &quot;true&quot;
+ description = &quot;Launches example programs&quot;
+ perspective= &quot;com.example.JavaPerspective&quot;&gt;</tt>
+<tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/launcher&gt;</tt>
+<tt>&nbsp;&nbsp; &lt;/extension&gt;</tt> </pre>
+
+<p>In the example above, the specified launcher supports both run and debug modes.
+Following a successful launch, the debug UI will change to the Java perspective. When the
+debug UI presents the user with a list of launchers to choose from, &quot;Example
+Launcher&quot; will appear as one of the choices with the &quot;Launches example
+programs&quot; as the description, and the wizard specified by <font face="Courier New">com.example.launchers.ui.ExampleLaunchWizard</font>
+will be used to configure any launch specific details.</p>
+
+<p><b><i>API Information: </i></b>Value of the attribute <b>class</b> must be a fully
+qualified class name of a Java class that implements the interface <font size="2"
+face="Courier New">org.eclipse.debug.core.ILauncher</font>Delegate. Value of the attribute
+<strong>wizard</strong> must be a fully qualified class name of a Java class that
+implements <font size="2" face="Courier New">org.eclipse.debug.ui.ILaunchWizard</font>.<br>
+<br>
+</p>
+
+<p><a href="hglegal.htm"><img src="ngibmcpy.gif" alt="Copyright IBM Corporation 2000"
+border="0" width="195" height="12"></a></p>
+</body>
+</html>
diff --git a/org.eclipse.debug.core/exportplugin.xml b/org.eclipse.debug.core/exportplugin.xml
new file mode 100644
index 000000000..fa5508934
--- /dev/null
+++ b/org.eclipse.debug.core/exportplugin.xml
@@ -0,0 +1,28 @@
+<!-- Export a jar of .class files for the org.eclipse.debug.core Eclipse plugin
+ along with other important plugin files to the "plugin-export" subdirectory
+ of the target Eclipse installation -->
+<project name="org.eclipse.debug.core" default="export" basedir=".">
+
+ <!-- Set the timestamp and important properties -->
+ <target name="init">
+ <tstamp/>
+ <property name="destdir" value="../../plugin-export" />
+ <property name="dest" value="${destdir}/org.eclipse.debug.core" />
+ </target>
+
+ <!-- Create the jar of .class files, and copy other important files to export dir -->
+ <target name="export" depends="init">
+ <mkdir dir="${destdir}" />
+ <delete dir="${dest}" />
+ <mkdir dir="${dest}" />
+ <jar
+ jarfile="${dest}/dtcore.jar"
+ basedir="bin"
+ />
+ <copy file="plugin.xml" todir="${dest}"/>
+ <copy file="plugin.jars" todir="${dest}"/>
+ <copy file=".classpath" todir="${dest}"/>
+ <copy file=".options" todir="${dest}"/>
+ </target>
+
+</project>
diff --git a/org.eclipse.debug.core/plugin.jars b/org.eclipse.debug.core/plugin.jars
new file mode 100644
index 000000000..e50828df4
--- /dev/null
+++ b/org.eclipse.debug.core/plugin.jars
@@ -0,0 +1 @@
+dtcore.jar=Eclipse Debug Core \ No newline at end of file
diff --git a/org.eclipse.debug.core/plugin.xml b/org.eclipse.debug.core/plugin.xml
new file mode 100644
index 000000000..ad155ed20
--- /dev/null
+++ b/org.eclipse.debug.core/plugin.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0"?>
+
+<plugin
+ name = "DebugTools"
+ id = "org.eclipse.debug.core"
+ version = "0.105.0"
+ vendor-name = "OTI"
+ class="org.eclipse.debug.core.DebugPlugin">
+
+<requires>
+ <import plugin="org.apache.xerces"/>
+ <import plugin="org.eclipse.core.resources"/>
+</requires>
+
+<runtime>
+ <library name="dtcore.jar" >
+ <export name= "*" />
+ </library>
+</runtime>
+
+<extension-point name="Launcher" id="launchers"/>
+
+<extension id="breakpoint" point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.core.resources.marker"/>
+ <persistent value="true"/>
+ <attribute name="modelIdentifier"/>
+ <attribute name="enabled"/>
+</extension>
+
+<extension id="lineBreakpoint" point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.debug.core.breakpoint"/>
+ <super type="org.eclipse.core.resources.textmarker"/>
+ <persistent value="true"/>
+</extension>
+
+</plugin>
+

Back to the top