| Feature | Description |
|---|
| Standards Based |
JDebugTool requires JDK 1.5 (Java 5) or JDK 1.6 (Java 6) to run itself.
Built on top of the standard JPDA (Java Debugger Platform
Architecture), JDebugTool should be able to debug any JPDA compliant JVM --
debugging targets of JDK 1.3, JDK 1.4,
JDK 1.5 (Java 5) or JDK 1.6 (Java 6) are supported.
|
| Cross-Platform |
JDebugTool is totally written in Java itself. |
| Intuitive & Graphical |
The Java Swing GUI
is logically divided into resizable panels
and popup windows. Data is color coded, and displayed in trees and tables (tables can be sorted and
table columns can be hidden or shown).
There are tool tips, right-click popup context menus and keyboard accelerators throughout the GUI. |
| Help Viewer |
JDebugTool has an integrated Help Viewer.
Context sensitive help is available throughout the GUI. |
| Global Settings |
Specify whether the Main Window is divided into a four or six resizable
division layout. Change the Look and Feel and also the font size of the GUI.
Specify a hint for the maximum number of lines in a tool tip. |
| Object Tool Tips |
View beginning object fields, array values, and String data as tool tips,
throughout the GUI. |
| Projects |
Debugger settings are saved according to projects.
There is always a default project, if you do not want to create any projects. |
| Source Files | Each source file is displayed (syntax color coded) in its own tabbed pane.
The left margin annotates the line numbers, breakpoints and the current Execution Point. |
| External Text Editor |
Launch a User definable External Text Editor in which to edit the currently
displayed Java source file. |
| Search |
Find a particular string or go to a particular line number in a Source File. |
| Source Tree |
Traverse your source code tree(s) and
display selected source files. |
| Navigator |
Display (and quickly navigate to) the class (including inner classes) and corresponding
methods hierarchy obtained by parsing the top displayed Java source file. |
| Classes Hierarchy |
Displays the hierarchy of classes (and inner classes) that have
been loaded into the target JVM, according to the corresponding ClassLoader.
For each class the attributes, methods and fields
are displayed. The corresponding source code can be displayed for each
class and its methods. |
| Breakpoints |
Set breakpoint(s) at a particular line
number or method of a class. Breakpoints can be enabled, disabled and cleared. |
| Breakpoint Groups |
Breakpoints can belong
to breakpoint groups. Breakpoints can be cleared, enabled and disabled based on
breakpoint group. |
| Exceptions |
Stop execution when a particular exception or any uncaught
exception is thrown. Debugger exceptions can be filtered based on thrown location,
and also enabled and disabled. |
| Chained Exceptions | The debugger supports the (JDK 1.4 or later) chained exceptions
feature -- each exception in the chain is displayed. |
| Watchpoints |
Stop on class field access (read), or modification (write) combined with comparison
(==, !=, <, <=, >, >=) to a particular value.
The watchpoint can be constrained to a particular object instance (JDK 1.4 or later). |
| Thread Start & Death Events |
Stop execution on thread start and stop events -- filter by
thread name or thread group. |
| Class Prepare & Unload Events |
Stop on class prepare and unload events --
filter by class name or package name with class name wild card. |
| Method Entry & Exit Events |
Stop on method entry and
exit events, selectable on a per thread basis. |
| Execution |
Single step (step in, over and out of methods)
and run to cursor, resume, suspend and restart execution. |
| Stepping Excludes |
The user can
specify classes not to step into (like 3rd party packages). |
| Locals |
View local variables (and types) in the current scope. |
| This |
View object fields (and types) [including the inheritance hierarchy]
in the current scope. |
| Watches |
Watch key local variables and object (this) fields (and types) in the current scope.
Also watch array and field accesses in the current scope, and also static fields. |
| Objects |
View the fields (and types) of an object [including the inheritance hierarchy].
Drill down into object references.
Object IDs are displayed throughout the GUI. |
| To String |
Invoke the toString() method on an object and view the resulting
string. |
| Arrays |
View selected array ranges. |
| Modify Variables |
Modify the values of primitive variables directly in the GUI. |
| Expressions and Invoke Methods |
Interactively evaluate simple expressions
including method calls. |
| Source Variables |
View variables in the current scope in the source code. |
| Threads |
View the current threads (including thread object ID, name, status and group).
Change the current context of the debugger to a particular thread.
Interrupt execution of a particular thread causing an
InterruptedException to be thrown. |
| Stack |
View the current stack backtrace and traverse individual stack frames
to change the current context of the debugger. |
| Run |
The debugger can invoke the target JVM to be debugged. The main class
and arguments, classpath, and JVM arguments can be specified. |
| Standard Input/Output |
If the debugger invoked the target JVM, then the
(color-coded) standard input, output and error streams are displayed.
The user can type the standard input to be sent to the target. |
| Local & Remote Debugging |
Debug the target JVM executing locally or remotely separated by a network. |
| Attach |
The debugger can attach to a target JVM that has been invoked outside
the debugger. |
| Listen |
The debugger can listen for a target JVM (that has been invoked outside
the debugger) to connect to the debugger. |
| Target Info |
Displays information about the target JVM such as
the bootclasspath, the classpath, version and debugging capabilities. |
| Connectors |
Displays the debugging connectors supported by your host JVM. |
| Memory Usage |
Display the memory usage of JDebugTool itself. |
| System Properties |
Display the Java System properties of JDebugTool itself. |
| Hot Swap |
The debugger supports the (JDK 1.4 or later) Hot Swap
feature. This supports fix and continue debugging, and also updating a long running server program without
restarting the server program. |
| Pop Stack Frame(s) |
The debugger supports the (JDK 1.4 or later) Pop stack
frame(s) feature. This supports re-executing method(s) particularly those that are
Hot Swapped. |
