Breakpoints allow users to suspend the execution of a program at a particular
location. Breakpoints are typically shown in the UI along with the source
code. When a breakpoint is encountered during execution of a program, the program suspends
and triggers a SUSPEND debug event with BREAKPOINT as the
If your plug-in needs to show breakpoints in its UI, you can add an
IBreakpointManager is the
central authority over all breakpoints. Breakpoints are added and removed using the breakpoint manager, which in
turn informs any listeners about breakpoint activity. The operation of breakpoints can be enabled or disabled
using the breakpoint manager. The breakpoint manager can be obtained from the
IBreakpointManager mgr = DebugPlugin.getDefault().getBreakpointManager();
Plug-ins that define their own debug models and launch configurations often
need to define their own breakpoint types. You can implement breakpoints
for your particular debug model by defining a class that implements
Breakpoints are implemented using
Recall that resource markers allow you to associate meta information about a
resource in the form of named attributes. By implementing a breakpoint
using markers, the debug model can make use of all the existing marker function
such as persistence, searching, adding, deleting, and displaying in editors.
Why is it important to know about markers when using breakpoints? When
you create a breakpoint type, you must also specify an associated marker
type. Every extension of
should be accompanied by an extension of
This is best demonstrated by looking at the extensions defined by the Java
tooling for Java breakpoints.
<extension id="javaBreakpointMarker" point="org.eclipse.core.resources.markers">
<extension id="javaExceptionBreakpointMarker" point="org.eclipse.core.resources.markers">
The debug plug-in defines a special type of marker, org.eclipse.debug.core.breakpointMarker.
When you define a breakpoint marker for your debugger, you should declare it using this marker as a super
type. This allows the debug model to find all possible breakpoints within
a source file by searching for subtypes of its marker. In the example
above, the javaExceptionBreakpointMarker has a super type, javaBreakpointMarker,
whose super type is the breakpointMarker. The javaExceptionBreakpoint
(defined in the breakpoint extension) designates the javaExceptionBreakpointMarker
as its marker.
What does all of this mean? When the debug code obtains
a source code file, it can search for all markers whose super type is
org.eclipse.debug.core.breakpointMarker. Having found all of the markers, it can then
use the extension registry to map the markers to their associated breakpoint classes.
In this way, the platform debug code can generically find all breakpoint types that have been set on a
particular source file.