Package org.eclipse.debug.core.model

Defines interfaces for a debug model elements, source lookup, and launching.

See:
Description

Interface Summary

IBreakpoint	A breakpoint is capable of suspending the execution of a program at a specific location when a program is running in debug mode.
IDebugElement	A debug element represents an artifact in a program being debugged.
IDebugTarget	A debug target is a debuggable execution context.
IDisconnect	The ability to end a debug session with a target program and allow the target to continue running.
IExpression	An expression is a snippet of code that can be evaluated to produce a value.
ILaunchConfigurationDelegate	A launch configuration delegate performs launching for a specific type of launch configuration.
ILineBreakpoint	A breakpoint that can be located at a specific line of source code.
IMemoryBlock	A contiguous segment of memory in an execution context.
IMemoryBlockRetrieval	Supports the retrieval of arbitrary blocks of memory.
IPersistableSourceLocator	A source locator that can be persisted and restored, to be used with a specfic launch configuration.
IProcess	A process represents a program running in normal (non-debug) mode.
IRegister	A register is a special kind of variable that is contained in a register group.
IRegisterGroup	A register group is a group of registers that are assigned to a stack frame.
ISourceLocator	A source locator locates source elements for stack frames.
IStackFrame	A stack frame represents an execution context in a suspended thread.
IStep	Provides the ability to step into, over, and return from the current execution location.
IStreamMonitor	A stream monitor manages the contents of the stream a process is writing to, and notifies registered listeners of changes in the stream.
IStreamsProxy	A streams proxy acts as proxy between the streams of a process and interested clients.
ISuspendResume	Provides the ability to suspend and resume a thread or debug target.
ITerminate	Provides the ability to terminate an execution context - for example, a thread, debug target or process.
IThread	A thread is a sequential flow of execution in a debug target.
IValue	A value represents the value of a variable.
IValueModification	Provides the ability to modify the value of a variable in a target.
IVariable	A variable represents a visible data structure in a stack frame or value.

Class Summary

Breakpoint	Abstract implementation of a breakpoint.
LineBreakpoint	Abstract implementation of a line breakpoint.

Package org.eclipse.debug.core.model Description

Defines interfaces for a debug model elements, source lookup, and launching.

Package Specification

This package defines classes and interfaces known as the "debug model" which support an extensible set of debug architectures and languages. The debug model is 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 Platform Debug Architecture (JPDA).

The Debug Model

A client implements a debug model by providing an implementation of the interfaces defined in this package. (There is no explicit extension point that represents a debug model). Each debug model provides one or more launch configuration types capable of initiating a debug session.

The common elements defined by the debug model are:

• Debug Target - A debug target represents a debuggable program - for example, a virtual machine or a process.
• Thread - A debug target may contain one or more threads.
• Stack Frame - A suspended thread may contain one or more stack frames.
• Variable - A stack frame may contain variables.
• Value - Each variable has an associated value, and a value may contain more variables (to represent complex data structures and objects).
• Register Group - A stack frame may (optionally) be associated with one or more register groups.
• Register - A register group contains one or more registers.
• Memory Blocks - A debug target may (optionally) support the retrieval of arbitrary contiguous segments of memory.
• Breakpoint - Breakpoints suspend the execution of a program.
• Expression - An expression is a snippet of code that can be evaluated to produce a value.

A debug model implementation is responsible for firing debug events. A debug event corresponds to an event in a program being debugged - for example the creation or termination of a thread.

Breakpoints

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, and the information required to create those breakpoints is dictated by each debug architecture. The debug platform supports an extensible set of breakpoint via the breakpoints extension point.

The debug platform provides a breakpoint manager that maintains the collection of all registered breakpoints. Clients add and remove breakpoints via this manager. Breakpoints are implemented by instances of IBreakpoint. Each breakpoint object has an associated marker, which provides persistence and presentation in editors. The debug platform defines a generic breakpoint and line breakpoint, as well as their corresponding marker definitions. Breakpoint creation is a client responsibility - that is, defining the attributes of a breakpoint and the resource to associate a breakpoint marker with.

Also, the location in which a breakpoint may be placed, and the attributes that a debug target requires to install a breakpoint are specific to each debug architecture, and thus a client responsibility.

Persistence

Breakpoints are persisted via their underlying marker. Breakpoint markers defined with the persisted attribute as false will not be persisted. Breakpoints are restored at workspace startup time by the breakpoint manager - that is, breakpoint objects are created for all persisted markers which are a subtype of the root breakpoint marker and are added to the breakpoint manager. To allow for selective persistence of breakpoints (of the same kind), the IBreakpoint interface and root breakpoint implementation define a "persisted" attribute. If this value is set to false, the breakpoint will not be persisted across workspace invocations.

Change Notification

As breakpoint markers are modified (created, removed, and 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. Debug targets that support breakpoints should register for breakpoint change notifications.