/Hello,/
/I’m in the process of developing a debugger for a hardware platform
our company has developed. The platform debugger understands both java
and assembly as the source language(s). For assembly, we have our own
file extension to direct the editor and invoke our runtime adapter
factory for breakpoint creation, etc when we toggle for breakpoints in
the ruler. However, for java source we cannot do this since we want
only java projects with a nature we’ve supplied to be intercepted and
processed with our breakpoint code. Java in projects without our
nature should be directed to the standard JDT. Furthermore, in some
instances, Java code with our nature would still be directed to the
JDT/JVM if we’re launching a simulation. The “Eclipse Debugger How-to”
suggests supplying a new source editor and adapting it. Will this
mechanism work when multiple plug-ins registering different editors
but still associated to edit files of the same extension, i.e. .java? /
/If we have to write our own editor, we want to inherit all the
features of the existing java editor with the exception of setting
breakpoints. We want to be able to set our own breakpoints. When I say
all the features, I even mean the parsing of the java code and the
production of the AST. Is inheriting all the java editor features as
easy as extending JavaEditor even though it’s internal, or are we in
for a lot of work?/
/We've considered alternatives. For instance, we could let the java
editor set its own breakpoints, and then at launch time we would
create our version of the breakpoint. Our version of the breakpoint
would never be registered with the BreakpointManager. If the user
deletes a breakpoint from a launched program we could listen to the
BreakpointManager to know when we should delete our version of the
breakpoint. /
/Ultimately, we want to defer the decision of capturing the toggle and
setting breakpoints in our hardware or setting the breakpoint in the
JVM to happen dynamically at toggle time, not editor configuration
time or plug-in install time. For instance, if we’re running an
application in simulation mode, we want to send the toggle to the
standard JVM handler, if we’ve launched a session that communicates
with our hardware, we want to send breakpoint to our hardware. This
bring up the issue of deferred breakpoint installation. Prior to
launch, we don’t know where to direct the breakpoint (JVM or our
hardware). When we eventually launch we’ll be able to direct all the
breakpoints to our hardware, but won’t the JVM already have attempted
to install the breakpoint requests? How can we either circumvent the
JVM from installing the breakpoints or backout the install requests./
/Is this possible or are there other mechanisms we should be using to
direct the toggle action?/
/ /
/Thanks,/
/ /Rick
------------------------------------------------------------------------
_______________________________________________
platform-debug-dev mailing list
platform-debug-dev@xxxxxxxxxxx
https://dev.eclipse.org/mailman/listinfo/platform-debug-dev
