+ * 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 getSource 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.
+ *
+ * The generic CHANGE 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 CHANGE 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.
+ *
IDebugTarget
+ * CREATE - a debug target has been created and is ready
+ * to begin a debug session.TERMINATE - a debug target has terminated and the debug
+ * session has ended.IThread
+ * CREATE - a thread has been created in a debug target.TERMINATE - a thread has ended.SUSPEND - a thread has suspended. Event detail provides
+ * the reason for the suspension, or -1 if unknown:RESUME - a thread has resumed. Event detail provides
+ * the reason for the resume, or -1 if unknown:IStackFrame - 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.
+ * IVariable - no events are specified for variables.
+ * When a thread is suspended, stack frames have variables. When a thread resumes,
+ * variables are unavailable.
+ * IValue - no events are specified for values.
+ * IProcess
+ * CREATE - a system process has been created.TERMINATE - a system process has terminated.+ * Clients may instantiate this class. Clients are not intended to subclass this class. + *
+ *+ * Note: 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. + *
+ */ +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 inIDebugEventConstants)
+ */
+ 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.
+ * + * Clients may instantiate this class. Clients are not intended to subclass this class. + *
+ *+ * Note: 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. + *
+ * @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 + *DebugPlugin.getDefault(). The debug plugin provides:
+ * + * Clients may not instantiate or subclass this class. + *
+ *+ * Note: 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. + *
+ */ +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...true 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.
+ * + * An instance of this plug-in runtime class is automatically created + * when the facilities provided by the Resources plug-in are required. + * Clients must never explicitly instantiate a plug-in runtime class. + *
+ * + * @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. + *+ * This method will be automatically invoked by the platform when + * the platform is shut down. + *
+ * Clients must never explicitly call this method. + * + * @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. + *+ * This method is automatically invoked by the platform + * the first time any code in this plug-in is executed. + *
+ * Clients must never explicitly call this method. + * + * @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 + *java.lang.Process. 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.
+ * + * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ * @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, ornull 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.
+ *
+ * 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 configureBreakpoint(IMarker, String, boolean)
+ * and configureLineBreakpoint(IMarker, String, boolean, int, int, int).
+ *
All breakpoints have:
+ * 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. + *
+ *
+ * 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 IBreakpointSupport) are
+ * informed of breakpoint additions, removals, and changes if they
+ * respond true to supportsBreakpoints().
+ * A debug target is responsible for installing all existing
+ * (applicable) breakpoints when created.
+ *
+ * This interface is not intended to be implemented by clients. + *
+ *+ * Note: 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. + *
+ * @see IMarker + * @see org.eclipse.debug.core.model.IBreakpointSupport + */ +public interface IBreakpointManager { + + /** + * Configures the given breakpoint'sMODEL_IDENTIFIER
+ * and ENABLED attributes to the given values.
+ * This is a convenience method for
+ * IMarker.setAttribute(String, String) and
+ * IMarker.setAttribute(String, boolean).
+ *
+ * @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 MODEL_IDENTIFIER,
+ * ENABLED, LINE_NUMBER, CHAR_START,
+ * and CHAR_END attributes to the given values.
+ * This is a convenience method for
+ * IMarker.setAttribute(String, String),
+ * IMarker.setAttribute(String, boolean), and
+ * IMarker.setAttribute(String, int).
+ *
+ * @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:MODEL_IDENTIFIER attribute
+ * is not set on the breakpoint marker.CoreException occurred while verifying the MODEL_IDENTIFIER
+ * attribute.ENABLED attribute of the
+ * given breakpoint - true if the breakpoint is enabled,
+ * otherwise false. By default, if the attribute has not
+ * been set, a breakpoint is considered enabled.
+ * Note, this method returns false
+ * if an exception occurs while accessing the attribute. This is
+ * a convenience method for
+ * IMarker.getAttribute(String, boolean).
+ *
+ * @param breakpoint the breakpoint
+ * @return whether the breakpoint is enabled
+ * @see IMarker#getAttribute(String, boolean)
+ */
+ boolean isEnabled(IMarker breakpoint);
+
+ /**
+ * Sets the value of the ENABLED attribute of the
+ * given breakpoint. This is a convenience method for
+ * IMarker.setAttribute(String, boolean).
+ *
+ * @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 LINE_NUMBER 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 IMarker.getAttribute(String, int).
+ *
+ * @param breakpoint the breakpoint
+ * @return the breakpoint's line number, or -1 if unknown
+ */
+ int getLineNumber(IMarker breakpoint);
+
+ /**
+ * Returns the value of the CHAR_START 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 IMarker.getAttribute(String, int)
+ *
+ * @param breakpoint the breakpoint
+ * @return the breakpoint's char start value, or -1 if unknown
+ */
+ int getCharStart(IMarker breakpoint);
+
+ /**
+ * Returns the value of the CHAR_END 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 IMarker.getAttribute(String, int).
+ *
+ * @param breakpoint the breakpoint
+ * @return the breakpoint's char end value, or -1 if unknown
+ */
+ int getCharEnd(IMarker breakpoint);
+
+ /**
+ * Returns the value of the MODEL_IDENTIFIER attribute of the
+ * given breakpoint or null if the attribute is not present or
+ * an exception occurs while accessing the attribute. This is a convenience method
+ * for IMarker.getAttribute(String, String).
+ *
+ * @param breakpoint the breakpoint
+ * @return the breakpoint's debug model plug-in identifier, or null
+ * 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 delete 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.
+ * + * Constants only; not intended to be implemented. + *
+ *+ * Note: 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. + *
+ */ +public interface IDebugConstants { + + /** + * Debug infrastructure plug-in identifier + * (value"org.eclipse.debug.core").
+ */
+ public static final String PLUGIN_ID = "org.eclipse.debug.core";
+
+ /**
+ * Launcher extension point identifier
+ * (value "launchers").
+ */
+ public static final String EXTENSION_POINT_LAUNCHER= "launchers";
+
+ /**
+ * Root breakpoint marker type
+ * (value "org.eclipse.debug.core.breakpoint").
+ */
+ public static final String BREAKPOINT_MARKER = PLUGIN_ID + ".breakpoint";
+
+ /**
+ * Line breakpoint marker type.
+ * (value "org.eclipse.debug.core.lineBreakpoint").
+ */
+ public static final String LINE_BREAKPOINT_MARKER = PLUGIN_ID + ".lineBreakpoint";
+
+ /**
+ * Debug model identifier breakpoint marker attribute
+ * (value "modelIdentifier").
+ * This attribute is a String 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 "enabled").
+ * The attribute is a boolean 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.
+ *
+ * Clients may implement this interface.
+ *
+ *
+ * Note: 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.
+ *
+ * @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.
+ *
+ * Constants only; not intended to be implemented.
+ *
+ *
+ * Note: 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.
+ *
+ * @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.
+ *
+ * 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 Launch.
+ *
+ *
+ * Note: 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.
+ *
+ * @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:IDebugTarget or IProcess)
+ */
+ Object[] getChildren();
+ /**
+ * Returns the debug target associated with this launch, or null
+ * if no debug target is associated with this launch.
+ *
+ * @return the debug target associated with this launch, or null
+ */
+ IDebugTarget getDebugTarget();
+ /**
+ * Returns the object that was launched. Cannot return null.
+ *
+ * @return the launched object
+ */
+ Object getElement();
+ /**
+ * Returns the launcher that was used to launch. Cannot return null.
+ *
+ * @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 null
+ * 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.
+ *
+ * Clients may implement this interface.
+ *
+ *
+ * Note: 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.
+ *
+ * @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.
+ *
+ * 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.
+ *
+ *
+ * Clients are not intended to implement this interface.
+ *
+ *
+ * Note: 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.
+ *
+ * @see ILaunch
+ * @see ILaunchListener
+ */
+public interface ILaunchManager extends IAdaptable {
+ /**
+ * A launch in a normal, non-debug mode(value "run").
+ */
+ public static final String RUN_MODE= "run";
+ /**
+ * A launch in a special debug mode (value "debug").
+ */
+ 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 null
+ * no registered launches contains the process.
+ *
+ * @param process the process for which to find a launch
+ * @return the launch containing the process, or null if none
+ */
+ ILaunch findLaunch(IProcess process);
+ /**
+ * Returns the launch the given debug target is contained
+ * in, or null 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 null 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 null 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 null 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 ("org.eclipse.debug.core.launchers").
+ * It manages the attributes of a launcher extension, and lazily instantiates the
+ * delegate when required.
+ *
+ * This interface is not intended to be implemented by clients. Clients
+ * that define a launcher extension implement the ILauncherDelegate
+ * interface.
+ *
+ *
+ * NOTE: 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.
+ *
+ * @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 String constants - one or both of
+ * ILaunchManager.RUN_MODE, ILaunchManager.DEBUG_MODE
+ * @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
+ * "org.eclipse.ui.perspective" 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.
+ *
+ * Clients may implement this interface.
+ *
+ *
+ * Note: 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.
+ *
+ * @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 ILaunch.
+ *
+ * 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.
+ *
+ *
+ * Note: 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.
+ *
+ * @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 null 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 null 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
+ * null if not supported
+ * @param processes the processes created by this launch, empty
+ * or null if none
+ * @param target the debug target created by this launch, or null
+ * 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 true
+ * from supportsBreakpoint(IMarker). The breakpoint manager
+ * removes debug targets from its listener list as launches
+ * are deregistered.
+ *
+ * Clients may implement this interface.
+ *
+ *
+ * Note: 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.
+ *
+ */
+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.
+ *
+ * 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.
+ *
+ *
+ * @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.
+ *
+ * Some methods on debug elements require communication
+ * with the target program. Such methods may throw a DebugException
+ * with a status code of TARGET_REQUEST_FAILED
+ * 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.
+ *
+ *
+ * Debug elements are language independent. However, language specific
+ * features can be made available via the adpater mechanism provided by
+ * IAdaptable, or by extending the debug element interfaces.
+ * A debug model is responsible for declaring any special adapters
+ * its debug elements implement.
+ *
+ *
+ * Clients may implement this interface.
+ *
+ *
+ * Note: 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.
+ *
+ */
+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
+ * null if this element is not registered with
+ * a launch. This is a convenience method for
+ * ILaunchManager.findLaunch(getDebugTarget()).
+ *
+ * @return this element's launch, or null 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 null
+ * if this element has no parent.
+ *
+ * @return this element's parent, or null if none
+ */
+ IDebugElement getParent();
+ /**
+ * Returns the process associated with this debug element,
+ * or null 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 null if none
+ */
+ IProcess getProcess();
+ /**
+ * Returns the source locator that can be used to locate source elements
+ * associated with this element or null 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 null if none
+ */
+ ISourceLocator getSourceLocator();
+ /**
+ * Returns the stack frame containing this element,
+ * or null if this element is not contained in a stack frame.
+ *
+ * @return this element's stack frame, or null if none
+ */
+ IStackFrame getStackFrame();
+ /**
+ * Returns the thread containing this element,
+ * or null if this element is not contained in a thread.
+ *
+ * @return this element's thread, or null 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 DEBUG_TARGET,
+ * children of type THREAD, and no parent. Minimally, a debug target supports
+ * the following capabilities:
+ *
+ * - terminate
+ *
- suspend/resume
+ *
- breakpoints
+ *
- diconnect
+ *
+ *
+ * Generally, launching a debug session results in the creation of a
+ * debug target. Launching is a client responsibility, as is debug target
+ * creation.
+ *
+ * Clients may implement this interface.
+ *
+ *
+ * Note: 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.
+ *
+ * @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 null 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.
+ *
+ * Clients may implement this interface.
+ *
+ *
+ * Note: 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.
+ *
+ * @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:
+ * - TARGET_REQUEST_FAILED - The request failed in the target
+ *
- NOT_SUPPORTED - The capability is not supported by the target
+ *
+ */
+ 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
+ * org.eclipse.debug.core.launchers 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.
+ *
+ * A launcher extension is defined in plugin.xml.
+ * Following is an example definition of a launcher extension.
+ *
+ * <extension point="org.eclipse.debug.core.launchers">
+ * <launcher
+ * id="com.example.ExampleIdentifier"
+ * class="com.example.ExmapleLauncher"
+ * modes="run, debug"
+ * label="Example Launcher"
+ * wizard="com.example.ExampleLaunchWizard"
+ * layout="com.example.JavaLayout">
+ * </launcher>
+ * </extension>
+ *
+ * The attributes are specified as follows:
+ *
+ * id specifies a unique identifier for this launcher.class specifies the fully qualified name of the java class
+ * that implements this interface.modes specifies a comma separated list of the modes this
+ * launcher supports - "run" and/or "debug.label specifies a human readable label for this launcher
+ * extension.wizard specifies the fully qualified name of the java class
+ * that implements org.eclipse.debug.ui.ILaunchWizard. The debug UI
+ * may invoke the wizard to perform a launch, or this launcher extension
+ * may present the wizard when asked to launch.
layout specifies the identifier of a layout that should be
+ * used to present the resulting launch.
+ *
+ *
+ * + * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ * @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. + * Returnstrue if successful, otherwise false.
+ * 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.
+ * + * 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. + *
+ *+ * 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. + *
+ * + * @param elements an array of objects providing a context for the launch + * @param mode run or debug (as defined byILaunchManager.RUN_MODE,
+ * ILaunchManager.DEBUG_MODE)
+ * @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.
+ *
+ * Clients may implement this interface, however, the debug plug-in
+ * provides an implementation of this interface for a
+ * java.lang.Process.
+ *
+ * Note: 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. + *
+ * @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 theILaunch this element originated from, or
+ * null if this element has not yet been registered with
+ * an ILaunch. This is a convenience method for
+ * ILaunchManager.findLaunch(IProcess).
+ *
+ * @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 null if not supported.
+ *
+ * @return a streams proxy, or null 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 null 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.
+ * + * 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. + *
+ *+ * 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. + *
+ *+ * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ * @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 + *null 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.
+ * + * 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. + *
+ * + * @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 typeSTACK_FRAME, and a parent
+ * of type THREAD. The children of a stack frame are of
+ * type VARIABLE, and represent the visible variables in
+ * the stack frame. Minimally, a stack frame supports
+ * the following capabilities:
+ * + * 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. + *
+ *+ * 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. + *
+ *+ * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ * @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-1 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.
+ * + * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ */ +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. + *
+ * For example, a thread is considered to be stepping
+ * after the stepOver call until the step over is completed,
+ * a breakpoint is reached, an exception is thrown, or the thread or is
+ * terminated.
+ *
RESUME
+ * and SUSPEND 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:RESUME
+ * and SUSPEND 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:RESUME and SUSPEND 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:
+ * Clients may implement this interface. Generally, a client that
+ * provides an implementation of the IStreamsProxy
+ * interface must also provide an implementation of this interface.
+ *
+ * Note: 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. + *
+ * @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 aString
+ */
+ 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 IProcess to handle I/O related
+ * to the standard input, output, and error streams associated
+ * with a process.
+ *
+ * Clients implementing the IProcess interface must also
+ * provide an implementation of this interface.
+ *
+ * Note: 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. + *
+ * @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, + * ornull if not supported.
+ * The monitor is connected to the error stream of the
+ * associated process.
+ *
+ * @return an input stream monitor, or null if none
+ */
+ public IStreamMonitor getErrorStreamMonitor();
+ /**
+ * Returns a monitor for the output stream of this proxy's process,
+ * or null if not supported.
+ * The monitor is connected to the output stream of the
+ * associated process.
+ *
+ * @return an input stream monitor, or null 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 OutputStream.
+ *
+ */
+ 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.
+ * + * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ */ +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:+ * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ */ +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:THREAD, and a parent
+ * of type DEBUG_TARGET. The children of a thread are of
+ * type STACK_FRAME. A thread only has children when
+ * suspended, and children are returned in top-down order.
+ * Minimally, a thread supports the following capabilities:
+ * + * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ * @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 ornull if there is
+ * currently no top stack frame.
+ *
+ * @return the top stack frame, or null 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 VARIABLE.
+ * + * 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. + *
+ *+ * 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. + *
+ *+ * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ * @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 aString.
+ *
+ * @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 IValue
+ * return null. Values do not have names.
+ *
+ * @return null
+ */
+ String getName();
+
+ /**
+ * Returns the variable this value is bound to, or null
+ * if this value is not bound to a variable.
+ *
+ * @return a variable, or null if none
+ */
+ IVariable getVariable();
+
+ /**
+ * Returns the parent of this element. Implementations of IVariable
+ * return null. Values do not have parents.
+ *
+ * @return null
+ */
+ IDebugElement getParent();
+
+ /**
+ * Returns whether this value is currently allocated.
+ *
+ * For example, if this value represents
+ * an object that has been garbage collected, false would
+ * be returned.
+ *
+ * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ * @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:VARIABLE.
+ * A variable's parent may be of type
+ * STACK_FRAME or VALUE.
+ * Each variable has a value which may in turn
+ * have children. A variable itself does not have children.
+ * A variable may support value modification.
+ * + * 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. + *
+ *+ * 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. + *
+ *+ * Clients may implement this interface. + *
+ *+ * Note: 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. + *
+ * @see IValue + * @see IStackFrame + * @see IValueModification + */ +public interface IVariable extends IDebugElement, IValueModification { + /** + * Returns the children of this elemnet. Implementations of + *IVariable 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 @@
+
+
+
+
+
+Note: 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.
+ +A language independent "debug model" is represented by the set of interfaces +defined in org.eclipse.debug.core.model. 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 "launcher" 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.
+ +The common elements defined by the debug plug-in are: + +
Debug model elements and breakpoints are displayed in the workbench. To support +configurable and extensible presentation, the debug UI plug-in defines the debugModelPresentations 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: + +
Provides support for launching programs and defines interfaces for a debug model to +support an extensible set debug architectures.
+ +Note: 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.
+ +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 "debug +model" - 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).
+ +The "debug model" is represented by the set of interfaces defined in org.eclipse.debug.core.model. 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 "launcher" 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.
+ +The common elements defined by the debug plug-in are: + +
Debug model elements and breakpoints are displayed in the workbench. To support +configurable and extensible presentation, the debugModelPresentations +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: + +
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.
+ +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.
+ +The breakpoint definitions in plug-in org.eclipse.debug.core +are as follows:
+ + +<extension id="breakpoint"
+point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.core.resources.marker"/>
+ <persisted value="true"/>
<extension id="lineBreakpoint"
+point="org.eclipse.core.resources.markers">
+ <super type="org.eclipse.debug.core.breakpoint"/>
+ <super type="org.eclipse.core.resources.textmarker"/>
+ <persisted value="true"/>
+</extension>
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: + +
Note that verifying the location of the breakpoint is valid is also a client +responsibility.
+ +Breakpoints are persisted via the standard marker mechanism. Breakpoints defined with +the persisted attribute as false +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 "persisted" attribute. If +this value is set to false, the breakpoint will not be persisted.
+ +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).
+ +Removing a breakpoint from the breakpoint manager signals the end of the breakpoint +lifecycle. A breakpoint may be removed with the method org.eclipse.debug.core.IBreakpointManager.removeBreakpoint(IMarker), +or by deleting the underlying marker (in the later case, the breakpoint manager notices a +breakpoint has been deleted, and automatically removes it).
+ +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.
+ +Debug targets are notified of breakpoints via the IBreakpointListener +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 org.eclipse.debug.core.IBreakpointManager.getBreakpoints(String), +which provides a list of active breakpoints for a specific debug model.
+ + 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. + *
+ * This method, along with the startReading
+ * method is used to allow InputStreamMonitor
+ * to implement Runnable without publicly
+ * exposing a run 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 Thread 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 QualifiedName
+ * 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 null.
+ */
+ 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 null 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 ILaunchManager
+ */
+ 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 null 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 true if there are no registered listeners,
+ * false 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 IProcess being monitored.
+ */
+ protected RuntimeProcess fProcess;
+ /**
+ * The java.lang.Process being monitored.
+ */
+ protected Process fOSProcess;
+ /**
+ * The Thread 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;
+
+ /**
+ * true 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 OutputStream of the IProcess.
+ */
+ protected OutputStream fOutputStream;
+ /**
+ * Records the open/closed state of communications with
+ * the underlying streams.
+ */
+ protected boolean fClosed= false;
+ /**
+ * Creates a StreamsProxy on the streams
+ * of the given IProcess.
+ */
+ 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 @@
+
+
+
+
Licensed Materials - Property of IBM
+WebSphere Studio Workbench
+(c) Copyright IBM Corp. 2000 All Rights Reserved.
US Government Users Restricted Rights - Use, duplication or disclosure restricted by +GSA ADP Schedule Contract with IBM Corp.
+ + 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 Binary files /dev/null and b/org.eclipse.debug.core/doc/ngibmcpy.gif 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 @@ + + + + + +The debug tools infrastructure plug-in, org.eclipse.debug.core,
+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.
+
The following extension points are used to support and extend the debug infrastructure: + +
+ +
Identifier: org.eclipse.debug.core.launchers
+ +Description: 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.
+ +Configuration Markup:
+ +<!ATTLIST launcher + id CDATA #REQUIRED + class CDATA #REQUIRED + modes CDATA #REQUIRED + label CDATA #REQUIRED + wizard CDATA #IMPLIED + public CDATA #IMPLIED + description CDATA #IMPLIED + perspective CDATA #IMPLIED + >+ +
Examples:
+ +The following is an example of a launcher extension point:
+ +<extension + point = "org.eclipse.debug.core.launchers"> + <launcher + id = "com.example.ExampleLauncher" + class = "com.example.launchers.ExampleLauncher" + modes = "run, debug" + label = "Example Launcher" + wizard = "com.example.launchers.ui.ExampleLaunchWizard" + public = "true" + description = "Launches example programs" + perspective= "com.example.JavaPerspective"> + </launcher> + </extension>+ +
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, "Example +Launcher" will appear as one of the choices with the "Launches example +programs" as the description, and the wizard specified by com.example.launchers.ui.ExampleLaunchWizard +will be used to configure any launch specific details.
+ +API Information: Value of the attribute class must be a fully
+qualified class name of a Java class that implements the interface org.eclipse.debug.core.ILauncherDelegate. Value of the attribute
+wizard must be a fully qualified class name of a Java class that
+implements org.eclipse.debug.ui.ILaunchWizard.
+
+